everything-dev 1.3.7 → 1.4.1

package/src/cli/init.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import {
   createWriteStream,
   existsSync,
@@ -19,6 +20,7 @@ import {
   normalizePackageManifestsInTree,
 } from "../internal/manifest-normalizer";
 import type { BosConfig } from "../types";
+import { writeSnapshot } from "./snapshot";
 
 const require = createRequire(import.meta.url);
 
@@ -29,8 +31,8 @@ interface SourceResult {
 }
 
 export async function resolveSourceDir(opts: {
-  account: string;
-  gateway: string;
+  extendsAccount: string;
+  extendsGateway: string;
   source?: string;
 }): Promise<SourceResult> {
   if (opts.source) {
@@ -44,7 +46,7 @@ export async function resolveSourceDir(opts: {
     return { sourceDir, parentConfig, cleanup: async () => {} };
   }
 
-  const parentConfig = await fetchParentConfig(opts.account, opts.gateway);
+  const parentConfig = await fetchParentConfig(opts.extendsAccount, opts.extendsGateway);
 
   if (!parentConfig.repository) {
     throw new Error("Parent config has no repository field — cannot locate template source");
@@ -54,8 +56,11 @@ export async function resolveSourceDir(opts: {
   return { sourceDir, parentConfig, cleanup };
 }
 
-export async function fetchParentConfig(account: string, gateway: string): Promise<BosConfig> {
-  const bosUrl = `bos://${account}/${gateway}`;
+export async function fetchParentConfig(
+  extendsAccount: string,
+  extendsGateway: string,
+): Promise<BosConfig> {
+  const bosUrl = `bos://${extendsAccount}/${extendsGateway}`;
   return fetchBosConfigFromFastKv<BosConfig>(bosUrl);
 }
 
@@ -187,9 +192,9 @@ export async function copyFilteredFiles(
 export async function personalizeConfig(
   destination: string,
   opts: {
-    parentAccount: string;
-    parentGateway: string;
-    name?: string;
+    extendsAccount: string;
+    extendsGateway: string;
+    account?: string;
     domain?: string;
     workspaceOpts?: { localOverrides?: boolean; sourceDir?: string };
   },
@@ -198,10 +203,10 @@ export async function personalizeConfig(
   if (existsSync(configPath)) {
     const config = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
 
-    config.extends = `bos://${opts.parentAccount}/${opts.parentGateway}`;
+    config.extends = `bos://${opts.extendsAccount}/${opts.extendsGateway}`;
 
-    if (opts.name) {
-      config.account = opts.name;
+    if (opts.account) {
+      config.account = opts.account;
     }
     if (opts.domain) {
       config.domain = opts.domain;
@@ -352,6 +357,50 @@ async function resolveWorkspaceRefs(
   }
 }
 
+export async function writeInitSnapshot(
+  destination: string,
+  extendsAccount: string,
+  extendsGateway: string,
+  sourceDir: string,
+  patterns: string[],
+  options: { withHost: boolean },
+): Promise<void> {
+  const effectivePatterns = options.withHost
+    ? [...patterns, "host/**"]
+    : patterns.filter((p) => !p.startsWith("host/") && p !== "host/**");
+
+  const allFiles = new Set<string>();
+  for (const pattern of effectivePatterns) {
+    const matches = await glob(pattern, {
+      cwd: sourceDir,
+      nodir: true,
+      dot: true,
+      absolute: false,
+    });
+    for (const match of matches) {
+      allFiles.add(match);
+    }
+  }
+
+  const fileHashes: Record<string, string> = {};
+  for (const filePath of allFiles) {
+    const src = join(sourceDir, filePath);
+    const stat = lstatSync(src);
+    if (!stat.isFile()) continue;
+    const content = readFileSync(src);
+    fileHashes[filePath] = computeHash(content);
+  }
+
+  await writeSnapshot(destination, {
+    parentRef: `bos://${extendsAccount}/${extendsGateway}`,
+    files: fileHashes,
+  });
+}
+
+function computeHash(data: Uint8Array): string {
+  return createHash("sha256").update(data).digest("hex").substring(0, 16);
+}
+
 function mkTmpDir(prefix: string): string {
   const base = join(tmpdir(), prefix);
   let attempt = 0;

package/src/cli/prompts.ts

@@ -25,39 +25,57 @@ export async function promptYesNo(question: string, defaultVal = false): Promise
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 
+function deriveDirectoryFromDomain(domain: string): string {
+  const firstSegment = domain.split(".")[0];
+  return firstSegment || domain;
+}
+
+function deriveAccountFromDomain(domain: string, extendsAccount: string): string {
+  const firstSegment = domain.split(".")[0];
+  if (!firstSegment) return "";
+  const suffix = extendsAccount.includes(".")
+    ? extendsAccount.substring(extendsAccount.indexOf(".") + 1)
+    : extendsAccount;
+  return `${firstSegment}.${suffix}`;
+}
+
 export async function promptInitOptions(input: {
+  extendsAccount?: string;
+  extendsGateway?: string;
+  directory?: string;
   account?: string;
-  gateway?: string;
-  destination?: string;
-  name?: string;
   domain?: string;
   withHost?: boolean;
 }): Promise<{
-  account: string;
-  gateway: string;
-  destination: string;
-  name?: string;
+  extendsAccount: string;
+  extendsGateway: string;
+  directory: string;
+  account?: string;
   domain?: string;
   withHost: boolean;
 }> {
-  const account = input.account || (await prompt("NEAR account", "dev.everything.near"));
+  const extendsAccount =
+    input.extendsAccount || (await prompt("Extends account", "dev.everything.near"));
 
-  const gateway = input.gateway || (await prompt("Gateway ID", "everything.dev"));
+  const extendsGateway =
+    input.extendsGateway || (await prompt("Extends gateway", "everything.dev"));
 
-  const destination = input.destination || (await prompt("Project directory", gateway));
+  const domain = input.domain || (await prompt("Project domain"));
 
-  const name = input.name || (await prompt("New project NEAR account (optional)", ""));
+  const accountDefault = domain ? deriveAccountFromDomain(domain, extendsAccount) : "";
+  const account = input.account || (await prompt("Project NEAR account", accountDefault));
 
-  const domain = input.domain || (await prompt("New project domain (optional)", ""));
+  const directoryDefault = domain ? deriveDirectoryFromDomain(domain) : extendsGateway;
+  const directory = input.directory || (await prompt("Project directory", directoryDefault));
 
   const withHost =
     input.withHost !== undefined ? input.withHost : await promptYesNo("Include host?", false);
 
   return {
-    account,
-    gateway,
-    destination,
-    name: name || undefined,
+    extendsAccount,
+    extendsGateway,
+    directory,
+    account: account || undefined,
     domain: domain || undefined,
     withHost,
   };

package/src/cli/snapshot.ts

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface SyncSnapshot {
+  parentRef: string;
+  timestamp: string;
+  files: Record<string, string>;
+}
+
+const SNAPSHOT_DIR = ".bos";
+const SNAPSHOT_FILE = "sync-snapshot.json";
+
+function snapshotPath(projectDir: string): string {
+  return join(projectDir, SNAPSHOT_DIR, SNAPSHOT_FILE);
+}
+
+export async function readSnapshot(projectDir: string): Promise<SyncSnapshot | null> {
+  const path = snapshotPath(projectDir);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content) as SyncSnapshot;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeSnapshot(
+  projectDir: string,
+  data: { parentRef: string; files: Record<string, string> },
+): Promise<void> {
+  const dir = join(projectDir, SNAPSHOT_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const snapshot: SyncSnapshot = {
+    parentRef: data.parentRef,
+    timestamp: new Date().toISOString(),
+    files: data.files,
+  };
+
+  writeFileSync(snapshotPath(projectDir), `${JSON.stringify(snapshot, null, 2)}\n`);
+}

package/src/cli/status.ts

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { StatusResult } from "../contract";
+import { fetchBosConfigFromFastKv } from "../fastkv";
+import { readSnapshot } from "./snapshot";
+
+const FRAMEWORK_PACKAGES = ["everything-dev", "every-plugin"];
+
+async function fetchLatestNpmVersion(packageName: string): Promise<string | null> {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) return null;
+    const data = (await response.json()) as { version: string };
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+function readInstalledVersion(projectDir: string, packageName: string): string | undefined {
+  const pkgPath = join(projectDir, "package.json");
+  if (!existsSync(pkgPath)) return undefined;
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as Record<string, unknown>;
+  const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+  const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+  const version = deps[packageName] || devDeps[packageName];
+  if (!version) return undefined;
+  return version.replace(/^[\^~>=]+/, "");
+}
+
+function checkEnvFile(projectDir: string): "found" | "missing" | "example-only" {
+  if (existsSync(join(projectDir, ".env"))) return "found";
+  if (existsSync(join(projectDir, ".env.example"))) return "example-only";
+  return "missing";
+}
+
+async function checkParentReachable(extendsRef: string | undefined): Promise<boolean | undefined> {
+  if (!extendsRef?.startsWith("bos://")) return undefined;
+  try {
+    const config = await fetchBosConfigFromFastKv(extendsRef);
+    return config !== null;
+  } catch {
+    return false;
+  }
+}
+
+export async function getStatus(projectDir: string): Promise<StatusResult> {
+  const configPath = join(projectDir, "bos.config.json");
+  if (!existsSync(configPath)) {
+    return {
+      status: "error",
+      error: "No bos.config.json found in current directory",
+      packages: [],
+      envFile: "missing",
+    };
+  }
+
+  const config = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+
+  const packages = [];
+  for (const name of FRAMEWORK_PACKAGES) {
+    const installed = readInstalledVersion(projectDir, name);
+    const latest = await fetchLatestNpmVersion(name);
+    packages.push({ name, installed, latest: latest ?? undefined });
+  }
+
+  const snapshot = await readSnapshot(projectDir);
+
+  const extendsRef = config.extends as string | undefined;
+  const parentReachable = await checkParentReachable(extendsRef);
+
+  return {
+    status: "ok",
+    extends: extendsRef,
+    account: config.account as string | undefined,
+    domain: config.domain as string | undefined,
+    packages,
+    lastSync: snapshot?.timestamp,
+    envFile: checkEnvFile(projectDir),
+    parentReachable,
+  };
+}

package/src/cli/sync.ts

@@ -0,0 +1,239 @@
+import { createHash } from "node:crypto";
+import {
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { glob } from "glob";
+import type { SyncOptions, SyncResult } from "../contract";
+import { personalizeConfig, readTemplatekeep, resolveSourceDir, runBunInstall } from "./init";
+import { readSnapshot, writeSnapshot } from "./snapshot";
+
+function readExcludeFile(filePath: string): string[] {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync(filePath, "utf-8");
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+
+export async function readTemplatesyncExclude(sourceDir: string): Promise<string[]> {
+  return readExcludeFile(join(sourceDir, ".templatesync-exclude"));
+}
+
+export function readLocalSyncExcludes(projectDir: string): string[] {
+  return readExcludeFile(join(projectDir, ".bos", "sync-local-exclude"));
+}
+
+function isExcluded(filePath: string, excludePatterns: string[]): boolean {
+  for (const pattern of excludePatterns) {
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      if (filePath.startsWith(`${prefix}/`) || filePath === prefix) return true;
+    } else if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      const slashIdx = filePath.indexOf("/", prefix.length + 1);
+      if (filePath.startsWith(`${prefix}/`) && slashIdx === -1) return true;
+    } else if (filePath === pattern || filePath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function computeLocalHash(projectDir: string, filePath: string): string | null {
+  const fullPath = join(projectDir, filePath);
+  if (!existsSync(fullPath)) return null;
+  try {
+    const content = readFileSync(fullPath);
+    return createHash("sha256").update(content).digest("hex").substring(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+function backupFiles(projectDir: string, filePaths: string[]): string | null {
+  const filesToBackup = filePaths.filter((f) => existsSync(join(projectDir, f)));
+  if (filesToBackup.length === 0) return null;
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join(projectDir, ".bos", "sync-backup", timestamp);
+
+  for (const filePath of filesToBackup) {
+    const src = join(projectDir, filePath);
+    const dest = join(backupDir, filePath);
+    mkdirSync(dirname(dest), { recursive: true });
+    copyFileSync(src, dest);
+  }
+
+  return backupDir;
+}
+
+export async function syncTemplate(projectDir: string, options: SyncOptions): Promise<SyncResult> {
+  const localConfig = JSON.parse(
+    readFileSync(join(projectDir, "bos.config.json"), "utf-8"),
+  ) as Record<string, unknown>;
+
+  const extendsRef = localConfig.extends as string | undefined;
+  if (!extendsRef?.startsWith("bos://")) {
+    return {
+      status: "error",
+      updated: [],
+      skipped: [],
+      added: [],
+      error: "No extends field found in bos.config.json — cannot determine parent",
+    };
+  }
+
+  const extendsMatch = extendsRef.match(/^bos:\/\/([^/]+)\/(.+)$/);
+  if (!extendsMatch) {
+    return {
+      status: "error",
+      updated: [],
+      skipped: [],
+      added: [],
+      error: `Invalid extends reference: ${extendsRef}`,
+    };
+  }
+
+  const extendsAccount = extendsMatch[1];
+  const extendsGateway = extendsMatch[2];
+
+  const { sourceDir, cleanup } = await resolveSourceDir({ extendsAccount, extendsGateway });
+
+  try {
+    const patterns = await readTemplatekeep(sourceDir);
+    if (patterns.length === 0) {
+      return {
+        status: "error",
+        updated: [],
+        skipped: [],
+        added: [],
+        error: "No .templatekeep found in template source",
+      };
+    }
+
+    const parentExcludes = await readTemplatesyncExclude(sourceDir);
+    const localExcludes = readLocalSyncExcludes(projectDir);
+    const excludePatterns = [...parentExcludes, ...localExcludes];
+
+    const allTemplateFiles = new Set<string>();
+    for (const pattern of patterns) {
+      const matches = await glob(pattern, {
+        cwd: sourceDir,
+        nodir: true,
+        dot: true,
+        absolute: false,
+      });
+      for (const match of matches) {
+        allTemplateFiles.add(match);
+      }
+    }
+
+    const snapshot = await readSnapshot(projectDir);
+
+    const updated: string[] = [];
+    const skipped: string[] = [];
+    const added: string[] = [];
+
+    for (const filePath of allTemplateFiles) {
+      if (isExcluded(filePath, excludePatterns)) continue;
+
+      const localHash = computeLocalHash(projectDir, filePath);
+      const sourceContent = readFileSync(join(sourceDir, filePath));
+      const sourceHash = createHash("sha256").update(sourceContent).digest("hex").substring(0, 16);
+
+      if (localHash === null) {
+        added.push(filePath);
+        continue;
+      }
+
+      if (localHash === sourceHash) continue;
+
+      const snapshotHash = snapshot?.files[filePath];
+
+      if (snapshotHash === undefined) {
+        updated.push(filePath);
+        continue;
+      }
+
+      if (localHash === snapshotHash) {
+        updated.push(filePath);
+      } else {
+        if (options.force) {
+          updated.push(filePath);
+        } else {
+          skipped.push(filePath);
+        }
+      }
+    }
+
+    if (options.dryRun) {
+      return {
+        status: "dry-run",
+        updated,
+        skipped,
+        added,
+      };
+    }
+
+    const filesToWrite = [...updated, ...added].filter((f) => !isExcluded(f, excludePatterns));
+
+    if (filesToWrite.length > 0) {
+      backupFiles(projectDir, filesToWrite);
+
+      for (const filePath of filesToWrite) {
+        const src = join(sourceDir, filePath);
+        const dest = join(projectDir, filePath);
+        mkdirSync(dirname(dest), { recursive: true });
+        writeFileSync(dest, readFileSync(src));
+      }
+    }
+
+    const newSnapshotFiles: Record<string, string> = {};
+    for (const filePath of allTemplateFiles) {
+      const src = join(sourceDir, filePath);
+      const stat = lstatSync(src);
+      if (!stat.isFile()) continue;
+      const content = readFileSync(src);
+      newSnapshotFiles[filePath] = createHash("sha256")
+        .update(content)
+        .digest("hex")
+        .substring(0, 16);
+    }
+
+    await writeSnapshot(projectDir, {
+      parentRef: `bos://${extendsAccount}/${extendsGateway}`,
+      files: newSnapshotFiles,
+    });
+
+    const account = (localConfig.account as string) || extendsAccount;
+    const domain = (localConfig.domain as string) || extendsGateway;
+
+    await personalizeConfig(projectDir, {
+      extendsAccount,
+      extendsGateway,
+      account,
+      domain,
+      workspaceOpts: { sourceDir },
+    });
+
+    if (!options.noInstall) {
+      await runBunInstall(projectDir);
+    }
+
+    return {
+      status: "synced",
+      updated,
+      skipped,
+      added,
+    };
+  } finally {
+    await cleanup();
+  }
+}