@syncular/cli 0.0.0-101

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

@@ -0,0 +1,67 @@
+{
+  "name": "@syncular/cli",
+  "version": "0.0.0-101",
+  "description": "Unified CLI for Syncular OSS and Spaces workflows",
+  "license": "MIT",
+  "author": "Benjamin Kniffler",
+  "homepage": "https://syncular.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/syncular/syncular-spaces.git",
+    "directory": "cli/bin"
+  },
+  "bugs": {
+    "url": "https://github.com/syncular/syncular-spaces/issues"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "syncular": "./npm/run.mjs",
+    "synclr": "./npm/run.mjs"
+  },
+  "files": [
+    "npm"
+  ],
+  "scripts": {
+    "postinstall": "node ./npm/install.mjs",
+    "tsgo": "tsgo --noEmit",
+    "test": "bun test test",
+    "doctor": "bun src/index.ts doctor",
+    "console": "bun src/index.ts console",
+    "login": "bun src/index.ts login",
+    "logout": "bun src/index.ts logout",
+    "whoami": "bun src/index.ts whoami",
+    "create:space": "bun src/index.ts create-space",
+    "create": "bun src/index.ts create",
+    "dev": "bun src/index.ts dev",
+    "typegen": "bun src/index.ts typegen",
+    "migrate:status": "bun src/index.ts migrate-status",
+    "migrate:up": "bun src/index.ts migrate-up",
+    "build": "bun src/index.ts build",
+    "eject": "bun src/index.ts eject",
+    "target": "bun src/index.ts target",
+    "deploy": "bun src/index.ts deploy",
+    "verify": "bun src/index.ts verify",
+    "deployments:list": "bun src/index.ts deployments",
+    "rollback": "bun src/index.ts rollback",
+    "release": "bun ../config/bin/publish.ts"
+  },
+  "devDependencies": {
+    "@syncular/cli-buildpack-contract-worker": "0.0.0-101",
+    "@syncular/cli-core": "0.0.0-101",
+    "@syncular/cli-runtime-dev": "0.0.0-101",
+    "@syncular/cli-template-spaces-app": "0.0.0-101",
+    "@syncular/cli-template-spaces-demo": "0.0.0-101",
+    "@syncular/cli-template-syncular-demo": "0.0.0-101",
+    "@syncular/cli-template-syncular-libraries": "0.0.0-101",
+    "cross-keychain": "^1.1.0",
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "syncular": "*",
+    "@types/bun": "^1.3.9",
+    "@types/react": "^19.2.14"
+  }
+}