@syncular/cli 0.0.0-44 → 0.0.0-48

package/npm/install.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  describeDefaultInstallPath,
+  describeReleaseArtifactName,
+  ensureInstalledBinary,
+  shouldSkipInstall,
+} from './shared.mjs';
+
+async function main() {
+  if (shouldSkipInstall()) {
+    return;
+  }
+
+  await ensureInstalledBinary({ verbose: true });
+  console.error(
+    `[syncular] installed ${describeReleaseArtifactName()} -> ${describeDefaultInstallPath()}`
+  );
+}
+
+main().catch((error) => {
+  const message =
+    error instanceof Error ? error.message : `Unknown error: ${String(error)}`;
+  console.error(`[syncular] install warning: ${message}`);
+  console.error('[syncular] binary will be downloaded on first CLI execution');
+  process.exit(0);
+});

package/npm/run.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { ensureInstalledBinary, resolvePackageVersion } from './shared.mjs';
+
+async function main() {
+  const binaryPath = await ensureInstalledBinary({ verbose: false });
+  const packageVersion = resolvePackageVersion();
+  const result = spawnSync(binaryPath, process.argv.slice(2), {
+    env: {
+      ...process.env,
+      SYNCULAR_CLI_NPM_VERSION: packageVersion,
+    },
+    stdio: 'inherit',
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (typeof result.status === 'number') {
+    process.exit(result.status);
+  }
+
+  process.exit(1);
+}
+
+main().catch((error) => {
+  const message =
+    error instanceof Error ? error.message : `Unknown error: ${String(error)}`;
+  console.error(`[syncular] failed to start CLI: ${message}`);
+  process.exit(1);
+});

package/npm/shared.mjs

@@ -0,0 +1,271 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream, existsSync, readFileSync } from 'node:fs';
+import { chmod, mkdir, rename, rm } from 'node:fs/promises';
+import { arch, homedir, platform } from 'node:os';
+import { dirname, join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+
+const RELEASE_REPOSITORY = 'syncular/syncular-cli-releases';
+const PACKAGE_JSON_URL = new URL('../package.json', import.meta.url);
+const USER_AGENT = '@syncular/cli';
+
+function readPackageMetadata() {
+  const raw = readFileSync(PACKAGE_JSON_URL, 'utf8');
+  return JSON.parse(raw);
+}
+
+function resolveExecutableTarget() {
+  const key = `${platform()}/${arch()}`;
+  switch (key) {
+    case 'darwin/arm64':
+      return 'bun-darwin-arm64';
+    case 'darwin/x64':
+      return 'bun-darwin-x64';
+    case 'linux/arm64':
+      return 'bun-linux-arm64';
+    case 'linux/x64':
+      return 'bun-linux-x64';
+    case 'win32/x64':
+      return 'bun-windows-x64';
+    default:
+      throw new Error(
+        `Unsupported platform/arch "${key}". No prebuilt Syncular CLI binary is available.`
+      );
+  }
+}
+
+function resolveCacheDirectory() {
+  const override = process.env.SYNCULAR_CLI_CACHE_DIR?.trim();
+  if (override) {
+    return override;
+  }
+
+  const xdg = process.env.XDG_CACHE_HOME?.trim();
+  if (xdg) {
+    return join(xdg, 'syncular', 'cli');
+  }
+
+  const osPlatform = platform();
+  if (osPlatform === 'darwin') {
+    return join(homedir(), 'Library', 'Caches', 'syncular', 'cli');
+  }
+
+  if (osPlatform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA?.trim();
+    if (localAppData && localAppData.length > 0) {
+      return join(localAppData, 'syncular', 'cli');
+    }
+    return join(homedir(), 'AppData', 'Local', 'syncular', 'cli');
+  }
+
+  return join(homedir(), '.cache', 'syncular', 'cli');
+}
+
+function releaseBaseUrl(version) {
+  return `https://github.com/${RELEASE_REPOSITORY}/releases/download/v${version}`;
+}
+
+function binaryFileName(version, target) {
+  const base = `syncular-${version}-${target}`;
+  return target.includes('windows') ? `${base}.exe` : base;
+}
+
+function installedBinaryName() {
+  return platform() === 'win32' ? 'syncular.exe' : 'syncular';
+}
+
+function resolveInstalledBinaryPath(version, target) {
+  return join(
+    resolveCacheDirectory(),
+    version,
+    target,
+    installedBinaryName()
+  );
+}
+
+function sha256File(path) {
+  const digest = createHash('sha256');
+  digest.update(readFileSync(path));
+  return digest.digest('hex');
+}
+
+function wait(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+async function fetchResponse(url) {
+  const maxAttempts = 3;
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, {
+        headers: { 'user-agent': USER_AGENT },
+        redirect: 'follow',
+      });
+
+      if (response.status >= 500 && attempt < maxAttempts) {
+        await wait(attempt * 300);
+        continue;
+      }
+
+      return response;
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts) {
+        await wait(attempt * 300);
+        continue;
+      }
+    }
+  }
+
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+
+  throw new Error(`Failed to fetch ${url}`);
+}
+
+async function fetchJson(url) {
+  const response = await fetchResponse(url);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download ${url} (HTTP ${response.status} ${response.statusText})`
+    );
+  }
+
+  return response.json();
+}
+
+async function downloadFile(url, destinationPath) {
+  const response = await fetchResponse(url);
+
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Failed to download ${url} (HTTP ${response.status} ${response.statusText})`
+    );
+  }
+
+  const tempPath = `${destinationPath}.tmp-${process.pid}-${Date.now()}`;
+  await mkdir(dirname(destinationPath), { recursive: true });
+
+  try {
+    await pipeline(
+      Readable.fromWeb(response.body),
+      createWriteStream(tempPath, { mode: 0o755 })
+    );
+
+    try {
+      await rename(tempPath, destinationPath);
+    } catch (error) {
+      if (!existsSync(destinationPath)) {
+        throw error;
+      }
+      await rm(tempPath, { force: true });
+    }
+
+    if (platform() !== 'win32') {
+      await chmod(destinationPath, 0o755);
+    }
+  } catch (error) {
+    await rm(tempPath, { force: true });
+    throw error;
+  }
+}
+
+export function resolvePackageVersion() {
+  const metadata = readPackageMetadata();
+  const version =
+    typeof metadata.version === 'string' ? metadata.version.trim() : '';
+  if (version.length === 0) {
+    throw new Error('Package version is missing in package.json');
+  }
+  return version;
+}
+
+function resolveManifestEntry(manifest, target) {
+  const binaries = Array.isArray(manifest?.binaries) ? manifest.binaries : [];
+  const entry = binaries.find(
+    (candidate) => candidate && candidate.target === target
+  );
+
+  if (!entry || typeof entry.file !== 'string') {
+    const available = binaries
+      .map((candidate) =>
+        candidate && typeof candidate.target === 'string'
+          ? candidate.target
+          : ''
+      )
+      .filter((value) => value.length > 0)
+      .join(', ');
+    throw new Error(
+      `No CLI binary entry for target "${target}". Available targets: ${available}`
+    );
+  }
+
+  return entry;
+}
+
+export function shouldSkipInstall() {
+  if (process.env.SYNCULAR_CLI_SKIP_DOWNLOAD === '1') {
+    return true;
+  }
+
+  return resolvePackageVersion() === '0.0.0';
+}
+
+export async function ensureInstalledBinary(options = {}) {
+  const verbose = options.verbose === true;
+  const version = resolvePackageVersion();
+  const target = resolveExecutableTarget();
+  const destinationPath = resolveInstalledBinaryPath(version, target);
+
+  if (existsSync(destinationPath)) {
+    return destinationPath;
+  }
+
+  const baseUrl = releaseBaseUrl(version);
+  const manifestUrl = `${baseUrl}/manifest.json`;
+  const manifest = await fetchJson(manifestUrl);
+  const entry = resolveManifestEntry(manifest, target);
+  const expectedSha256 =
+    typeof entry.sha256 === 'string' ? entry.sha256.trim().toLowerCase() : '';
+  const artifactName = entry.file;
+  const artifactUrl = `${baseUrl}/${artifactName}`;
+
+  if (verbose) {
+    console.error(`[syncular] downloading ${artifactName}`);
+    console.error(`[syncular] source ${artifactUrl}`);
+    console.error(`[syncular] install path ${destinationPath}`);
+  }
+
+  await downloadFile(artifactUrl, destinationPath);
+
+  if (expectedSha256.length > 0) {
+    const actualSha256 = sha256File(destinationPath);
+    if (actualSha256 !== expectedSha256) {
+      await rm(destinationPath, { force: true });
+      throw new Error(
+        `Checksum mismatch for ${artifactName}: expected ${expectedSha256}, got ${actualSha256}`
+      );
+    }
+  }
+
+  return destinationPath;
+}
+
+export function describeDefaultInstallPath() {
+  const version = resolvePackageVersion();
+  const target = resolveExecutableTarget();
+  return resolveInstalledBinaryPath(version, target);
+}
+
+export function describeReleaseArtifactName() {
+  const version = resolvePackageVersion();
+  const target = resolveExecutableTarget();
+  return binaryFileName(version, target);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/cli",
-  "version": "0.0.0-44",
+  "version": "0.0.0-48",
   "description": "Unified CLI for Syncular OSS and Spaces workflows",
   "license": "MIT",
   "author": "Benjamin Kniffler",
@@ -19,13 +19,14 @@
   },
   "type": "module",
   "bin": {
-    "syncular": "./src/index.ts",
-    "synclr": "./src/index.ts"
+    "syncular": "./npm/run.mjs",
+    "synclr": "./npm/run.mjs"
   },
   "files": [
-    "src"
+    "npm"
   ],
   "scripts": {
+    "postinstall": "node ./npm/install.mjs",
     "tsgo": "tsgo --noEmit",
     "test": "bun test test",
     "doctor": "bun src/index.ts doctor",
@@ -48,20 +49,18 @@
     "rollback": "bun src/index.ts rollback",
     "release": "bun ../config/bin/publish.ts"
   },
-  "dependencies": {
-    "@syncular/cli-buildpack-contract-worker": "0.0.0-44",
-    "@syncular/cli-core": "0.0.0-44",
-    "@syncular/cli-runtime-dev": "0.0.0-44",
-    "@syncular/cli-template-spaces-app": "0.0.0-44",
-    "@syncular/cli-template-spaces-demo": "0.0.0-44",
-    "@syncular/cli-template-syncular-demo": "0.0.0-44",
-    "@syncular/cli-template-syncular-libraries": "0.0.0-44",
+  "devDependencies": {
+    "@syncular/cli-buildpack-contract-worker": "0.0.0-48",
+    "@syncular/cli-core": "0.0.0-48",
+    "@syncular/cli-runtime-dev": "0.0.0-48",
+    "@syncular/cli-template-spaces-app": "0.0.0-48",
+    "@syncular/cli-template-spaces-demo": "0.0.0-48",
+    "@syncular/cli-template-syncular-demo": "0.0.0-48",
+    "@syncular/cli-template-syncular-libraries": "0.0.0-48",
     "cross-keychain": "^1.1.0",
     "ink": "^6.8.0",
     "react": "^19.2.4",
-    "syncular": "*"
-  },
-  "devDependencies": {
+    "syncular": "*",
     "@types/bun": "^1.3.9",
     "@types/react": "^19.2.14"
   }

package/src/args.ts

@@ -1,112 +0,0 @@
-import process from 'node:process';
-import type { ParsedArgs, RootCommand } from './types';
-
-const IMPLICIT_TRUE_FLAGS = new Set([
-  '--help',
-  '--version',
-  '--interactive',
-  '--no-interactive',
-  '--forms',
-  '--json',
-  '--force',
-  '--watch',
-  '--open',
-  '--dry-run',
-  '--yes',
-]);
-
-export function parseArgs(argv: string[]): ParsedArgs {
-  const flags = new Set<string>();
-  const flagValues = new Map<string, string>();
-  const positionals: string[] = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) {
-      continue;
-    }
-
-    if (!arg.startsWith('-')) {
-      positionals.push(arg);
-      continue;
-    }
-
-    if (arg.startsWith('--')) {
-      const eqIndex = arg.indexOf('=');
-      if (eqIndex > 0) {
-        const key = arg.slice(0, eqIndex);
-        const value = arg.slice(eqIndex + 1);
-        flags.add(key);
-        flagValues.set(key, value);
-        continue;
-      }
-
-      flags.add(arg);
-      const next = argv[index + 1];
-      if (
-        typeof next === 'string' &&
-        next.length > 0 &&
-        !next.startsWith('-')
-      ) {
-        flagValues.set(arg, next);
-        index += 1;
-      } else if (IMPLICIT_TRUE_FLAGS.has(arg)) {
-        flagValues.set(arg, 'true');
-      }
-      continue;
-    }
-
-    flags.add(arg);
-  }
-
-  const commandCandidate = positionals[0] ?? null;
-  const subcommand = positionals[1] ?? null;
-
-  return {
-    command: normalizeRootCommand(commandCandidate),
-    subcommand,
-    flags,
-    flagValues,
-    positionals,
-  };
-}
-
-function normalizeRootCommand(value: string | null): RootCommand | null {
-  if (!value) {
-    return null;
-  }
-
-  if (value === 'help') return 'help';
-  if (value === 'version') return 'version';
-  if (value === 'doctor') return 'doctor';
-  if (value === 'console') return 'console';
-  if (value === 'login') return 'login';
-  if (value === 'logout') return 'logout';
-  if (value === 'whoami') return 'whoami';
-  if (value === 'create-space') return 'create-space';
-  if (value === 'create') return 'create';
-  if (value === 'dev') return 'dev';
-  if (value === 'typegen') return 'typegen';
-  if (value === 'migrate-status') return 'migrate-status';
-  if (value === 'migrate-up') return 'migrate-up';
-  if (value === 'build') return 'build';
-  if (value === 'eject') return 'eject';
-  if (value === 'target') return 'target';
-  if (value === 'deploy') return 'deploy';
-  if (value === 'verify') return 'verify';
-  if (value === 'rollback') return 'rollback';
-  if (value === 'deployments') return 'deployments';
-  if (value === 'interactive') return 'interactive';
-
-  return null;
-}
-
-export function shouldRunInteractive(args: ParsedArgs): boolean {
-  if (args.flags.has('--no-interactive')) {
-    return false;
-  }
-  if (args.flags.has('--interactive')) {
-    return true;
-  }
-  return process.stdout.isTTY === true;
-}

package/src/auth-storage.ts

@@ -1,57 +0,0 @@
-import { deletePassword, getPassword, setPassword } from 'cross-keychain';
-
-const SYNCULAR_CLI_KEYCHAIN_SERVICE = 'syncular-cli';
-
-function sanitizeAccountSegment(value: string): string {
-  const sanitized = value.replace(/[^A-Za-z0-9._@-]/g, '-');
-  const collapsed = sanitized.replace(/-+/g, '-').replace(/^-+|-+$/g, '');
-  return collapsed.length > 0 ? collapsed : 'default';
-}
-
-function controlPlaneAccount(controlPlaneBase: string): string {
-  try {
-    const url = new URL(controlPlaneBase);
-    return `control-plane-${sanitizeAccountSegment(url.host)}`;
-  } catch {
-    return `control-plane-${sanitizeAccountSegment(controlPlaneBase)}`;
-  }
-}
-
-export async function readStoredControlPlaneToken(
-  controlPlaneBase: string
-): Promise<string | null> {
-  try {
-    const token = await getPassword(
-      SYNCULAR_CLI_KEYCHAIN_SERVICE,
-      controlPlaneAccount(controlPlaneBase)
-    );
-    const normalized = token?.trim() ?? '';
-    return normalized.length > 0 ? normalized : null;
-  } catch {
-    return null;
-  }
-}
-
-export async function writeStoredControlPlaneToken(args: {
-  controlPlaneBase: string;
-  token: string;
-}): Promise<void> {
-  await setPassword(
-    SYNCULAR_CLI_KEYCHAIN_SERVICE,
-    controlPlaneAccount(args.controlPlaneBase),
-    args.token
-  );
-}
-
-export async function clearStoredControlPlaneToken(
-  controlPlaneBase: string
-): Promise<void> {
-  try {
-    await deletePassword(
-      SYNCULAR_CLI_KEYCHAIN_SERVICE,
-      controlPlaneAccount(controlPlaneBase)
-    );
-  } catch {
-    // ignore missing keychain entries
-  }
-}

package/src/buildpacks/index.ts

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

package/src/buildpacks/registry.ts

@@ -1,47 +0,0 @@
-import type { ContractBuildpack } from '@syncular/cli-core';
-import { BUILDPACK_EXTENSION_MANIFEST } from '../extensions';
-
-type BuildpackManifest = typeof BUILDPACK_EXTENSION_MANIFEST;
-
-function buildBuildpackRegistry(manifest: BuildpackManifest) {
-  const entries = Object.entries(manifest);
-  const seenBuildpackIds = new Set<string>();
-
-  for (const [registryKey, manifestEntry] of entries) {
-    const buildpackId = manifestEntry.buildpack.id;
-    if (buildpackId.length === 0) {
-      throw new Error(`Buildpack "${registryKey}" has an empty id.`);
-    }
-
-    if (seenBuildpackIds.has(buildpackId)) {
-      throw new Error(`Duplicate buildpack id in manifest: "${buildpackId}".`);
-    }
-    seenBuildpackIds.add(buildpackId);
-  }
-
-  return Object.freeze(
-    Object.fromEntries(
-      entries.map(([registryKey, manifestEntry]) => [
-        registryKey,
-        manifestEntry.buildpack,
-      ])
-    )
-  ) as {
-    [K in keyof BuildpackManifest]: BuildpackManifest[K]['buildpack'];
-  };
-}
-
-const buildpackRegistry = buildBuildpackRegistry(BUILDPACK_EXTENSION_MANIFEST);
-
-const REGISTERED_BUILDPACKS = Object.freeze(Object.values(buildpackRegistry));
-const BUILDPACK_IDS = Object.freeze(
-  REGISTERED_BUILDPACKS.map((buildpack) => buildpack.id)
-) as readonly string[];
-
-export function listBuildpackIds(): readonly string[] {
-  return BUILDPACK_IDS;
-}
-
-export function getBuildpackById(id: string): ContractBuildpack | null {
-  return REGISTERED_BUILDPACKS.find((buildpack) => buildpack.id === id) ?? null;
-}

package/src/buildpacks/types.ts

@@ -1 +0,0 @@
-export type { ContractBuildpack } from '@syncular/cli-core';