@syncular/cli 0.0.0-108 → 0.0.0-113

package/src/commands/auth.ts

@@ -1,426 +0,0 @@
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import { createServer } from 'node:http';
-import process from 'node:process';
-import {
-  clearStoredControlPlaneToken,
-  writeStoredControlPlaneToken,
-} from '../auth-storage';
-import { CLI_NAME } from '../constants';
-import { parseBearerToken, resolveControlPlaneBase } from '../control-plane';
-import { resolveControlPlaneToken } from '../control-plane-token';
-import {
-  optionalBooleanFlag,
-  optionalFlag,
-  optionalIntegerFlag,
-} from '../flags';
-import { printError, printInfo } from '../output';
-
-interface AuthMeResponse {
-  actorId?: string;
-  source?: 'clerk' | 'local' | 'deploy_token';
-  clerkUserId?: string | null;
-  deployTokenId?: string | null;
-  deployTokenSpaceId?: string | null;
-  deployTokenScopes?: string[];
-  error?: string;
-  message?: string;
-}
-
-interface WhoAmIOutput {
-  controlPlane: string;
-  actorId: string | null;
-  source: AuthMeResponse['source'] | null;
-  clerkUserId: string | null;
-}
-
-function defaultCliAuthUrl(controlPlaneBase: string): string {
-  return `${controlPlaneBase.replace(/\/$/, '')}/cli-login`;
-}
-
-function openBrowser(url: string): boolean {
-  try {
-    if (process.platform === 'darwin') {
-      const child = spawn('open', [url], {
-        detached: true,
-        stdio: 'ignore',
-      });
-      child.unref();
-      return true;
-    }
-
-    if (process.platform === 'win32') {
-      const child = spawn('cmd', ['/c', 'start', '', url], {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-      });
-      child.unref();
-      return true;
-    }
-
-    const child = spawn('xdg-open', [url], {
-      detached: true,
-      stdio: 'ignore',
-    });
-    child.unref();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isAllowedCallbackHost(hostname: string): boolean {
-  const normalized = hostname.trim().toLowerCase();
-  return normalized === '127.0.0.1' || normalized === 'localhost';
-}
-
-async function waitForTokenViaBrowser(args: {
-  callbackHost: string;
-  callbackPort: number;
-  authUrl: string;
-  timeoutSeconds: number;
-}): Promise<string> {
-  if (!isAllowedCallbackHost(args.callbackHost)) {
-    throw new Error(
-      `Invalid --callback-host "${args.callbackHost}". Use 127.0.0.1 or localhost.`
-    );
-  }
-
-  const state = randomUUID();
-  let settled = false;
-  let resolveToken: ((token: string) => void) | null = null;
-  let rejectToken: ((error: Error) => void) | null = null;
-
-  const tokenPromise = new Promise<string>((resolve, reject) => {
-    resolveToken = resolve;
-    rejectToken = reject;
-  });
-
-  const server = createServer((req, res) => {
-    try {
-      const requestUrl = new URL(
-        req.url || '/',
-        `http://${args.callbackHost}:${listeningPort}`
-      );
-      if (requestUrl.pathname !== '/callback') {
-        res.statusCode = 404;
-        res.end('Not found');
-        return;
-      }
-
-      const responseHeaders = {
-        'Content-Type': 'text/html; charset=utf-8',
-      };
-
-      const callbackState = requestUrl.searchParams.get('state')?.trim() || '';
-      if (callbackState !== state) {
-        res.writeHead(400, responseHeaders);
-        res.end(
-          '<h2>CLI Login Failed</h2><p>Invalid state. Return to terminal.</p>'
-        );
-        if (!settled) {
-          settled = true;
-          rejectToken?.(new Error('CLI login state mismatch.'));
-        }
-        return;
-      }
-
-      const error = requestUrl.searchParams.get('error')?.trim();
-      if (error && error.length > 0) {
-        res.writeHead(400, responseHeaders);
-        res.end(
-          `<h2>CLI Login Failed</h2><p>${error}</p><p>Return to terminal.</p>`
-        );
-        if (!settled) {
-          settled = true;
-          rejectToken?.(new Error(`CLI login failed: ${error}`));
-        }
-        return;
-      }
-
-      const token = parseBearerToken(
-        requestUrl.searchParams.get('token')?.trim() || ''
-      );
-      if (token.length === 0) {
-        res.writeHead(400, responseHeaders);
-        res.end(
-          '<h2>CLI Login Failed</h2><p>Missing token in callback.</p><p>Return to terminal.</p>'
-        );
-        if (!settled) {
-          settled = true;
-          rejectToken?.(new Error('CLI login callback did not include token.'));
-        }
-        return;
-      }
-
-      res.writeHead(200, responseHeaders);
-      res.end(
-        '<h2>CLI Login Complete</h2><p>You can close this tab and return to the terminal.</p>'
-      );
-      if (!settled) {
-        settled = true;
-        resolveToken?.(token);
-      }
-    } catch (error: unknown) {
-      res.statusCode = 500;
-      res.end('Unexpected callback error');
-      if (!settled) {
-        settled = true;
-        rejectToken?.(
-          error instanceof Error
-            ? error
-            : new Error('Unexpected callback parsing error.')
-        );
-      }
-    }
-  });
-
-  let listeningPort = args.callbackPort;
-  await new Promise<void>((resolve, reject) => {
-    server.once('error', (error) =>
-      reject(error instanceof Error ? error : new Error(String(error)))
-    );
-    server.listen(args.callbackPort, args.callbackHost, () => {
-      const address = server.address();
-      if (!address || typeof address === 'string') {
-        reject(new Error('Failed to allocate callback server port.'));
-        return;
-      }
-      listeningPort = address.port;
-      resolve();
-    });
-  });
-
-  const callbackUrl = `http://${args.callbackHost}:${listeningPort}/callback`;
-  const loginUrl = new URL(args.authUrl);
-  loginUrl.searchParams.set('callback', callbackUrl);
-  loginUrl.searchParams.set('state', state);
-
-  const opened = openBrowser(loginUrl.toString());
-  if (opened) {
-    printInfo(`Opening browser for CLI authentication: ${loginUrl}`);
-  } else {
-    printInfo('Failed to auto-open browser. Open this URL manually:');
-    console.log(loginUrl.toString());
-  }
-
-  try {
-    const timeoutMs = args.timeoutSeconds * 1000;
-    const timeoutPromise = new Promise<string>((_, reject) => {
-      setTimeout(() => {
-        reject(
-          new Error(
-            `Timed out waiting for browser login callback after ${args.timeoutSeconds}s.`
-          )
-        );
-      }, timeoutMs);
-    });
-    return await Promise.race([tokenPromise, timeoutPromise]);
-  } finally {
-    server.close();
-  }
-}
-
-async function fetchAuthMe(args: {
-  controlPlaneBase: string;
-  token: string;
-}): Promise<{
-  ok: boolean;
-  status: number;
-  payload: AuthMeResponse | null;
-}> {
-  const response = await fetch(
-    `${args.controlPlaneBase.replace(/\/$/, '')}/auth/me`,
-    {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${args.token}`,
-      },
-    }
-  );
-
-  let payload: AuthMeResponse | null = null;
-  try {
-    payload = (await response.json()) as AuthMeResponse;
-  } catch {
-    payload = null;
-  }
-
-  return {
-    ok: response.ok,
-    status: response.status,
-    payload,
-  };
-}
-
-function printWhoAmIHuman(payload: WhoAmIOutput): void {
-  const rows: Array<{ label: string; value: string }> = [
-    { label: 'Status', value: 'authenticated' },
-    { label: 'Control Plane', value: payload.controlPlane },
-    { label: 'Actor ID', value: payload.actorId ?? '(missing)' },
-    { label: 'Auth Source', value: payload.source ?? '(unknown)' },
-  ];
-
-  if (payload.clerkUserId) {
-    rows.push({ label: 'Clerk User ID', value: payload.clerkUserId });
-  }
-
-  const keyWidth = rows.reduce(
-    (width, row) => Math.max(width, row.label.length),
-    0
-  );
-  const contentLines = rows.map(
-    (row) => `${row.label.padEnd(keyWidth)} : ${row.value}`
-  );
-  const title = 'syncular whoami';
-  const contentWidth = Math.max(
-    title.length,
-    ...contentLines.map((line) => line.length)
-  );
-  const horizontal = '─'.repeat(contentWidth + 2);
-
-  console.log(`╭${horizontal}╮`);
-  console.log(`│ ${title.padEnd(contentWidth)} │`);
-  console.log(`├${horizontal}┤`);
-  for (const line of contentLines) {
-    console.log(`│ ${line.padEnd(contentWidth)} │`);
-  }
-  console.log(`╰${horizontal}╯`);
-}
-
-export async function runLogin(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const controlPlaneBase = resolveControlPlaneBase(flagValues);
-    const providedToken = await resolveControlPlaneToken({
-      flagValues,
-      controlPlaneBase,
-      includeStdinToken: true,
-      includeStoredToken: false,
-    });
-
-    let token = providedToken;
-    if (!token) {
-      const callbackHost = optionalFlag(
-        flagValues,
-        '--callback-host',
-        '127.0.0.1'
-      );
-      const callbackPort = optionalIntegerFlag(
-        flagValues,
-        '--callback-port',
-        0,
-        { min: 0 }
-      );
-      const timeoutSeconds = optionalIntegerFlag(
-        flagValues,
-        '--timeout-seconds',
-        180,
-        { min: 0 }
-      );
-      if (timeoutSeconds <= 0) {
-        throw new Error('--timeout-seconds must be greater than 0.');
-      }
-      const authUrl = optionalFlag(
-        flagValues,
-        '--auth-url',
-        defaultCliAuthUrl(controlPlaneBase)
-      );
-      token = await waitForTokenViaBrowser({
-        callbackHost,
-        callbackPort,
-        authUrl,
-        timeoutSeconds,
-      });
-    }
-
-    const me = await fetchAuthMe({ controlPlaneBase, token });
-    if (!me.ok) {
-      throw new Error(
-        `Login failed (${me.status}): ${me.payload?.message || me.payload?.error || 'UNAUTHENTICATED'}`
-      );
-    }
-
-    await writeStoredControlPlaneToken({ controlPlaneBase, token });
-    console.log('CLI login saved.');
-    console.log(`Control plane: ${controlPlaneBase}`);
-    if (me.payload?.actorId) {
-      console.log(`Actor: ${me.payload.actorId}`);
-    }
-    if (me.payload?.source) {
-      console.log(`Auth source: ${me.payload.source}`);
-    }
-    return 0;
-  } catch (error: unknown) {
-    printError(
-      error instanceof Error ? error.message : 'Login failed unexpectedly.'
-    );
-    return 1;
-  }
-}
-
-export async function runLogout(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const controlPlaneBase = resolveControlPlaneBase(flagValues);
-    await clearStoredControlPlaneToken(controlPlaneBase);
-    console.log(`Cleared stored CLI token for ${controlPlaneBase}`);
-    return 0;
-  } catch (error: unknown) {
-    printError(
-      error instanceof Error ? error.message : 'Logout failed unexpectedly.'
-    );
-    return 1;
-  }
-}
-
-export async function runWhoAmI(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const jsonOutput = optionalBooleanFlag(flagValues, '--json', false);
-    const controlPlaneBase = resolveControlPlaneBase(flagValues);
-    const token = await resolveControlPlaneToken({
-      flagValues,
-      controlPlaneBase,
-      includeStdinToken: true,
-      includeStoredToken: true,
-    });
-
-    if (!token) {
-      printError(
-        `No control-plane token available. Run \`${CLI_NAME} login\` first (or pass --token).`
-      );
-      return 1;
-    }
-
-    const me = await fetchAuthMe({ controlPlaneBase, token });
-    if (!me.ok) {
-      throw new Error(
-        `whoami failed (${me.status}): ${me.payload?.message || me.payload?.error || 'UNAUTHENTICATED'}`
-      );
-    }
-
-    const output: WhoAmIOutput = {
-      controlPlane: controlPlaneBase,
-      actorId: me.payload?.actorId ?? null,
-      source: me.payload?.source ?? null,
-      clerkUserId: me.payload?.clerkUserId ?? null,
-    };
-
-    if (jsonOutput) {
-      console.log(JSON.stringify(output, null, 2));
-    } else {
-      printWhoAmIHuman(output);
-    }
-    return 0;
-  } catch (error: unknown) {
-    printError(
-      error instanceof Error ? error.message : 'whoami failed unexpectedly.'
-    );
-    return 1;
-  }
-}

package/src/commands/build.ts

@@ -1,210 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import process from 'node:process';
-import type { ContractBuildpack } from '../buildpacks';
-import { getBuildpackById, listBuildpackIds } from '../buildpacks';
-import { optionalBooleanFlag, optionalFlag } from '../flags';
-import { printError, printInfo } from '../output';
-import type { TargetId } from '../targets';
-import {
-  resolveEffectiveTargetId,
-  resolveTargetDefaultConfigPath,
-} from '../targets';
-
-function resolveBuildpack(args: {
-  targetId: TargetId;
-  flagValues: Map<string, string>;
-}): ContractBuildpack {
-  const fallbackBuildpackId = 'contract-worker';
-  const buildpackId = optionalFlag(
-    args.flagValues,
-    '--buildpack',
-    fallbackBuildpackId
-  );
-
-  const buildpack = getBuildpackById(buildpackId);
-  if (buildpack) {
-    return buildpack;
-  }
-
-  throw new Error(
-    `Unsupported --buildpack "${buildpackId}" for target "${args.targetId}". Supported buildpacks: ${listBuildpackIds().join(', ')}.`
-  );
-}
-
-function resolveContractPaths(args: {
-  targetId: TargetId;
-  flagValues: Map<string, string>;
-}): {
-  configPath: string;
-  explicitEntry: string | null;
-} {
-  const cwd = process.cwd();
-  const explicitEntry = args.flagValues.get('--entry')?.trim() || null;
-  const configPath = optionalFlag(
-    args.flagValues,
-    '--config',
-    resolveTargetDefaultConfigPath({
-      cwd,
-      targetId: args.targetId,
-    })
-  );
-
-  if (!explicitEntry && !existsSync(configPath)) {
-    throw new Error(
-      `Syncular config not found: ${configPath}. Provide --config or --entry.`
-    );
-  }
-
-  return {
-    configPath,
-    explicitEntry,
-  };
-}
-
-async function assertWritableOutputFile(args: {
-  filePath: string;
-  overwrite: boolean;
-}): Promise<void> {
-  if (!args.overwrite && existsSync(args.filePath)) {
-    throw new Error(
-      `Refusing to overwrite existing file: ${args.filePath}. Use --force true to overwrite output files.`
-    );
-  }
-  await mkdir(dirname(args.filePath), { recursive: true });
-}
-
-export async function runBuild(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const cwd = process.cwd();
-    const targetResolution = await resolveEffectiveTargetId({
-      cwd,
-      explicitTargetId: flagValues.get('--target')?.trim() || null,
-    });
-    const targetId = targetResolution.targetId;
-    const overwrite = optionalBooleanFlag(flagValues, '--force', false);
-    const buildpack = resolveBuildpack({
-      targetId,
-      flagValues,
-    });
-    const { configPath, explicitEntry } = resolveContractPaths({
-      targetId,
-      flagValues,
-    });
-
-    const outPath = resolve(
-      cwd,
-      optionalFlag(
-        flagValues,
-        '--out',
-        `.syncular/build/${targetId}/artifact.js`
-      )
-    );
-    const manifestPath = resolve(
-      cwd,
-      optionalFlag(
-        flagValues,
-        '--manifest',
-        `.syncular/build/${targetId}/manifest.json`
-      )
-    );
-
-    await assertWritableOutputFile({
-      filePath: outPath,
-      overwrite,
-    });
-    await assertWritableOutputFile({
-      filePath: manifestPath,
-      overwrite,
-    });
-
-    const migrationMetadata = await buildpack.inspect({
-      configPath,
-      explicitEntry,
-    });
-    const manifest = {
-      generatedAt: new Date().toISOString(),
-      target: targetId,
-      targetSource: targetResolution.source,
-      buildpack: buildpack.id,
-      schemaVersion: migrationMetadata.schemaVersion,
-      migrationDigest: migrationMetadata.migrationDigest,
-      migrationCount: migrationMetadata.migrationCount,
-      ...(explicitEntry ? { entry: explicitEntry } : { configPath }),
-    };
-    const { source, artifactHash } = await buildpack.build({
-      configPath,
-      explicitEntry,
-      commentTag: 'syncular-cli-build',
-      metadata: manifest,
-    });
-
-    await writeFile(outPath, source, 'utf8');
-    await writeFile(
-      manifestPath,
-      `${JSON.stringify(manifest, null, 2)}\n`,
-      'utf8'
-    );
-
-    printInfo('Build completed.');
-    console.log(`Target: ${targetId}`);
-    console.log(`Buildpack: ${buildpack.id}`);
-    console.log(`Artifact: ${outPath}`);
-    console.log(`Manifest: ${manifestPath}`);
-    console.log(`Artifact hash: ${artifactHash}`);
-    return 0;
-  } catch (error: unknown) {
-    printError(error instanceof Error ? error.message : 'Build failed.');
-    return 1;
-  }
-}
-
-export async function runEject(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const cwd = process.cwd();
-    const targetResolution = await resolveEffectiveTargetId({
-      cwd,
-      explicitTargetId: flagValues.get('--target')?.trim() || null,
-    });
-    const targetId = targetResolution.targetId;
-    const overwrite = optionalBooleanFlag(flagValues, '--force', false);
-    const buildpack = resolveBuildpack({
-      targetId,
-      flagValues,
-    });
-    const { configPath, explicitEntry } = resolveContractPaths({
-      targetId,
-      flagValues,
-    });
-    const outDir = resolve(
-      cwd,
-      optionalFlag(flagValues, '--out-dir', `.syncular/eject/${targetId}`)
-    );
-
-    const result = await buildpack.eject({
-      configPath,
-      explicitEntry,
-      targetId,
-      outDir,
-      overwrite,
-    });
-
-    printInfo('Eject completed.');
-    console.log(`Target: ${targetId}`);
-    console.log(`Buildpack: ${buildpack.id}`);
-    console.log(`Output directory: ${outDir}`);
-    console.log('Files:');
-    for (const filePath of result.files) {
-      console.log(`- ${filePath}`);
-    }
-    return 0;
-  } catch (error: unknown) {
-    printError(error instanceof Error ? error.message : 'Eject failed.');
-    return 1;
-  }
-}