everything-dev 1.3.7 → 1.4.1

package/src/cli/upgrade.ts

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { UpgradeOptions, UpgradeResult } from "../contract";
+import { runBunInstall } from "./init";
+import { syncTemplate } from "./sync";
+
+const FRAMEWORK_PACKAGES = ["everything-dev", "every-plugin"];
+
+interface NpmPackageInfo {
+  version: string;
+}
+
+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 NpmPackageInfo;
+    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 updatePackageVersion(projectDir: string, packageName: string, newVersion: string): void {
+  const pkgPath = join(projectDir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as Record<string, unknown>;
+
+  if (pkg.dependencies && typeof pkg.dependencies === "object") {
+    const deps = pkg.dependencies as Record<string, string>;
+    if (deps[packageName] !== undefined) {
+      deps[packageName] = `^${newVersion}`;
+    }
+  }
+
+  if (pkg.devDependencies && typeof pkg.devDependencies === "object") {
+    const deps = pkg.devDependencies as Record<string, string>;
+    if (deps[packageName] !== undefined) {
+      deps[packageName] = `^${newVersion}`;
+    }
+  }
+
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+}
+
+function buildChangelogUrl(
+  oldVersion: string | undefined,
+  newVersion: string,
+  parentConfig: Record<string, unknown> | null,
+): string | undefined {
+  if (!oldVersion || oldVersion === newVersion) return undefined;
+  const repoUrl = parentConfig?.repository as string | undefined;
+  if (!repoUrl) return undefined;
+
+  const githubMatch = repoUrl.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (!githubMatch) return undefined;
+
+  const [, owner, repo] = githubMatch;
+  return `https://github.com/${owner}/${repo}/compare/v${oldVersion}...v${newVersion}`;
+}
+
+export async function upgradeTemplate(
+  projectDir: string,
+  options: UpgradeOptions,
+): Promise<UpgradeResult> {
+  const pkgPath = join(projectDir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return {
+      status: "error",
+      packages: [],
+      error: "No package.json found in current directory",
+    };
+  }
+
+  const packages: UpgradeResult["packages"] = [];
+
+  for (const name of FRAMEWORK_PACKAGES) {
+    const installed = readInstalledVersion(projectDir, name);
+    const latest = await fetchLatestNpmVersion(name);
+
+    if (!latest) {
+      packages.push({ name, from: installed, to: installed ?? "unknown" });
+      continue;
+    }
+
+    packages.push({ name, from: installed, to: latest });
+  }
+
+  const hasUpdates = packages.some((p) => p.from !== p.to && p.from !== undefined);
+
+  if (options.dryRun) {
+    let changelogUrl: string | undefined;
+    if (hasUpdates) {
+      const configPath = join(projectDir, "bos.config.json");
+      let parentConfig: Record<string, unknown> | null = null;
+      if (existsSync(configPath)) {
+        try {
+          parentConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {}
+      }
+      const mainPkg = packages.find((p) => p.name === "everything-dev");
+      if (mainPkg?.from && mainPkg.from !== mainPkg.to) {
+        changelogUrl = buildChangelogUrl(mainPkg.from, mainPkg.to, parentConfig);
+      }
+    }
+
+    return {
+      status: "dry-run",
+      packages,
+      changelogUrl,
+    };
+  }
+
+  for (const pkg of packages) {
+    if (pkg.from !== undefined && pkg.from !== pkg.to) {
+      updatePackageVersion(projectDir, pkg.name, pkg.to);
+    }
+  }
+
+  if (hasUpdates && !options.noInstall) {
+    await runBunInstall(projectDir);
+  }
+
+  let syncResult: UpgradeResult["sync"];
+  if (!options.noSync) {
+    syncResult = await syncTemplate(projectDir, {
+      dryRun: false,
+      force: options.force,
+      noInstall: true,
+    });
+  }
+
+  let changelogUrl: string | undefined;
+  const mainPkg = packages.find((p) => p.name === "everything-dev");
+  if (mainPkg?.from && mainPkg.from !== mainPkg.to) {
+    const configPath = join(projectDir, "bos.config.json");
+    let parentConfig: Record<string, unknown> | null = null;
+    if (existsSync(configPath)) {
+      try {
+        parentConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      } catch {}
+    }
+    changelogUrl = buildChangelogUrl(mainPkg.from, mainPkg.to, parentConfig);
+  }
+
+  return {
+    status: "upgraded",
+    packages,
+    sync: syncResult,
+    changelogUrl,
+  };
+}

package/src/cli.ts

@@ -32,6 +32,20 @@ function printConfigView(result: {
   console.log();
 }
 
+function formatTimeAgo(isoTimestamp: string): string {
+  const now = Date.now();
+  const then = new Date(isoTimestamp).getTime();
+  const diffMs = now - then;
+  const diffMins = Math.floor(diffMs / 60_000);
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins} minute${diffMins > 1 ? "s" : ""} ago`;
+  const diffHours = Math.floor(diffMins / 60);
+  if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? "s" : ""} ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffDays < 30) return `${diffDays} day${diffDays > 1 ? "s" : ""} ago`;
+  return isoTimestamp.split("T")[0] ?? isoTimestamp;
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -96,18 +110,151 @@ async function main() {
       }
       console.log(colors.green(`${icons.ok} Project initialized`));
       console.log(`  ${colors.dim("Extends:")} ${result.extends}`);
-      console.log(`  ${colors.dim("Destination:")} ${result.destination}`);
-      if (result.name) console.log(`  ${colors.dim("Account:")} ${result.name}`);
+      console.log(`  ${colors.dim("Directory:")} ${result.directory}`);
+      if (result.account) console.log(`  ${colors.dim("Account:")} ${result.account}`);
       if (result.domain) console.log(`  ${colors.dim("Domain:")} ${result.domain}`);
       console.log(`  ${colors.dim("Files copied:")} ${result.filesCopied}`);
       console.log();
       console.log(colors.dim("  Next steps:"));
-      console.log(colors.dim(`    cd ${result.destination}`));
+      console.log(colors.dim(`    cd ${result.directory}`));
+      console.log(colors.dim("    cp .env.example .env   # then fill in your values"));
       if (result.status === "initialized" && !(input as any)?.noInstall) {
-        console.log(colors.dim("    bos dev --host remote"));
+        console.log(colors.dim("    bun run dev"));
       } else {
         console.log(colors.dim("    bun install"));
-        console.log(colors.dim("    bos dev --host remote"));
+        console.log(colors.dim("    bun run dev"));
+      }
+      console.log();
+      return;
+    }
+
+    if (descriptor.key === "sync") {
+      console.log();
+      if (result.status === "error") {
+        console.error(`[CLI] ${result.error || "Unknown error"}`);
+        process.exit(1);
+      }
+      if (result.status === "dry-run") {
+        console.log(colors.cyan(`${icons.ok} Dry run — no files written`));
+      } else {
+        console.log(colors.green(`${icons.ok} Template synced`));
+      }
+      if (result.updated.length > 0) {
+        console.log(`  ${colors.dim("Updated:")} ${result.updated.length} file(s)`);
+        for (const f of result.updated) console.log(`    ${colors.dim(f)}`);
+      }
+      if (result.added.length > 0) {
+        console.log(`  ${colors.dim("Added:")} ${result.added.length} file(s)`);
+        for (const f of result.added) console.log(`    ${colors.dim(f)}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(
+          `  ${colors.yellow("Skipped:")} ${result.skipped.length} file(s) (locally modified, use --force to overwrite)`,
+        );
+        for (const f of result.skipped) console.log(`    ${colors.dim(f)}`);
+      }
+      if (result.updated.length === 0 && result.added.length === 0 && result.skipped.length === 0) {
+        console.log(`  ${colors.dim("Already up to date")}`);
+      }
+      console.log();
+      return;
+    }
+
+    if (descriptor.key === "upgrade") {
+      console.log();
+      if (result.status === "error") {
+        console.error(`[CLI] ${result.error || "Unknown error"}`);
+        process.exit(1);
+      }
+      if (result.status === "dry-run") {
+        console.log(colors.cyan(`${icons.ok} Dry run — no changes applied`));
+      } else {
+        console.log(colors.green(`${icons.ok} Framework upgraded`));
+      }
+      for (const pkg of result.packages) {
+        if (pkg.from && pkg.from !== pkg.to) {
+          console.log(`  ${colors.dim(`${pkg.name}:`)} ${pkg.from} → ${pkg.to}`);
+        } else if (!pkg.from) {
+          console.log(`  ${colors.dim(`${pkg.name}:`)} ${pkg.to} (new)`);
+        } else {
+          console.log(`  ${colors.dim(`${pkg.name}:`)} ${pkg.to} (up to date)`);
+        }
+      }
+      if (result.changelogUrl) {
+        console.log(`  ${colors.dim("Changelog:")} ${result.changelogUrl}`);
+      }
+      if (result.sync) {
+        const sync = result.sync;
+        if (sync.updated.length > 0) {
+          console.log(`  ${colors.dim("Synced updated:")} ${sync.updated.length} file(s)`);
+        }
+        if (sync.added.length > 0) {
+          console.log(`  ${colors.dim("Synced added:")} ${sync.added.length} file(s)`);
+        }
+        if (sync.skipped.length > 0) {
+          console.log(
+            `  ${colors.yellow("Synced skipped:")} ${sync.skipped.length} file(s) (locally modified, use --force to overwrite)`,
+          );
+        }
+      }
+      console.log();
+      return;
+    }
+
+    if (descriptor.key === "status") {
+      console.log();
+      if (result.status === "error") {
+        console.error(`[CLI] ${result.error || "Unknown error"}`);
+        process.exit(1);
+      }
+      console.log(colors.cyan(frames.top(52)));
+      console.log(`  ${icons.app} ${gradients.cyber("STATUS")}`);
+      console.log(colors.cyan(frames.bottom(52)));
+      console.log();
+      if (result.extends) console.log(`  ${colors.dim("Extends:")}     ${result.extends}`);
+      if (result.account) console.log(`  ${colors.dim("Account:")}     ${result.account}`);
+      if (result.domain) console.log(`  ${colors.dim("Domain:")}      ${result.domain}`);
+      console.log();
+      console.log(`  ${colors.dim("Packages:")}`);
+      for (const pkg of result.packages) {
+        const hasUpdate = pkg.installed && pkg.latest && pkg.installed !== pkg.latest;
+        const versionStr = hasUpdate
+          ? `${pkg.installed}  →  ${pkg.latest}`
+          : pkg.installed || "not installed";
+        const label = hasUpdate ? colors.yellow(versionStr) : colors.dim(versionStr);
+        console.log(`    ${colors.dim(`${pkg.name}`)}  ${label}`);
+      }
+      console.log();
+      if (result.lastSync) {
+        const ago = formatTimeAgo(result.lastSync);
+        console.log(`  ${colors.dim("Last sync:")}   ${ago}`);
+      } else {
+        console.log(`  ${colors.dim("Last sync:")}   never`);
+      }
+      const envLabel =
+        result.envFile === "found"
+          ? colors.green("found")
+          : result.envFile === "example-only"
+            ? colors.yellow("missing (only .env.example found)")
+            : colors.error("missing");
+      console.log(`  ${colors.dim(".env:")}         ${envLabel}`);
+      if (result.parentReachable !== undefined) {
+        const parentLabel = result.parentReachable
+          ? colors.green("reachable")
+          : colors.error("unreachable");
+        console.log(`  ${colors.dim("Parent:")}      ${parentLabel}`);
+      }
+      const hasUpdates = result.packages.some(
+        (p: { installed?: string; latest?: string }) =>
+          p.installed && p.latest && p.installed !== p.latest,
+      );
+      if (hasUpdates) {
+        console.log();
+        console.log(
+          colors.dim(
+            `  Run ${colors.cyan("bos upgrade")} to update packages and sync template files.`,
+          ),
+        );
       }
       console.log();
       return;

package/src/contract.meta.ts

@@ -79,18 +79,48 @@ export const cliCommandMeta = {
     summary: "Scaffold a new project from a bos template",
     interactive: true,
     fields: {
-      account: {
+      domain: {
         positional: true,
-        description: "Parent NEAR account (defaults to dev.everything.near)",
+        description: "New project domain (e.g. ironclaw.everything.dev)",
       },
-      gateway: { positional: true, description: "Parent gateway ID (defaults to everything.dev)" },
-      destination: { description: "Target directory (defaults to ./gateway)" },
-      name: { description: "New project NEAR account" },
-      domain: { description: "New project domain" },
+      account: { description: "New project NEAR account (auto-derived from domain)" },
+      extendsAccount: {
+        description: "Parent NEAR account to extend from (defaults to dev.everything.near)",
+      },
+      extendsGateway: {
+        description: "Parent gateway to extend from (defaults to everything.dev)",
+      },
+      directory: { description: "Target directory (auto-derived from domain)" },
       source: { description: "Local source dir (skips GitHub download)" },
       withHost: { description: "Include host/ in template output" },
       noInteractive: { description: "Skip prompts, use flags only" },
       noInstall: { description: "Skip bun install" },
     },
   },
+  sync: {
+    commandPath: ["sync"],
+    summary: "Sync template files from parent project",
+    interactive: false,
+    fields: {
+      dryRun: { description: "Preview changes without writing files" },
+      force: { description: "Overwrite user-modified files" },
+      noInstall: { description: "Skip bun install" },
+    },
+  },
+  upgrade: {
+    commandPath: ["upgrade"],
+    summary: "Upgrade framework packages and sync template files",
+    interactive: false,
+    fields: {
+      dryRun: { description: "Preview changes without writing" },
+      force: { description: "Overwrite user-modified files during sync" },
+      noInstall: { description: "Skip bun install" },
+      noSync: { description: "Only upgrade packages, skip template sync" },
+    },
+  },
+  status: {
+    commandPath: ["status"],
+    summary: "Show project health, versions, and update availability",
+    interactive: false,
+  },
 } as const satisfies Record<string, CliCommandMeta>;

package/src/contract.ts

@@ -134,10 +134,10 @@ export const KeyPublishResultSchema = z.object({
 });
 
 export const InitOptionsSchema = z.object({
+  extendsAccount: z.string().optional(),
+  extendsGateway: z.string().optional(),
+  directory: z.string().optional(),
   account: z.string().optional(),
-  gateway: z.string().optional(),
-  destination: z.string().optional(),
-  name: z.string().optional(),
   domain: z.string().optional(),
   source: z.string().optional(),
   withHost: z.boolean().default(false),
@@ -147,16 +147,69 @@ export const InitOptionsSchema = z.object({
 
 export const InitResultSchema = z.object({
   status: z.enum(["initialized", "error"]),
-  destination: z.string(),
-  parentAccount: z.string(),
-  parentGateway: z.string(),
-  name: z.string().optional(),
+  directory: z.string(),
+  extendsAccount: z.string(),
+  extendsGateway: z.string(),
+  account: z.string().optional(),
   domain: z.string().optional(),
   extends: z.string(),
   filesCopied: z.number(),
   error: z.string().optional(),
 });
 
+export const SyncOptionsSchema = z.object({
+  dryRun: z.boolean().default(false),
+  force: z.boolean().default(false),
+  noInstall: z.boolean().default(false),
+});
+
+export const SyncResultSchema = z.object({
+  status: z.enum(["synced", "dry-run", "error"]),
+  updated: z.array(z.string()),
+  skipped: z.array(z.string()),
+  added: z.array(z.string()),
+  error: z.string().optional(),
+});
+
+export const UpgradeOptionsSchema = z.object({
+  dryRun: z.boolean().default(false),
+  force: z.boolean().default(false),
+  noInstall: z.boolean().default(false),
+  noSync: z.boolean().default(false),
+});
+
+export const UpgradeResultSchema = z.object({
+  status: z.enum(["upgraded", "dry-run", "error"]),
+  packages: z.array(
+    z.object({
+      name: z.string(),
+      from: z.string().optional(),
+      to: z.string(),
+    }),
+  ),
+  sync: SyncResultSchema.optional(),
+  changelogUrl: z.string().optional(),
+  error: z.string().optional(),
+});
+
+export const StatusResultSchema = z.object({
+  status: z.enum(["ok", "error"]),
+  extends: z.string().optional(),
+  account: z.string().optional(),
+  domain: z.string().optional(),
+  packages: z.array(
+    z.object({
+      name: z.string(),
+      installed: z.string().optional(),
+      latest: z.string().optional(),
+    }),
+  ),
+  lastSync: z.string().optional(),
+  envFile: z.enum(["found", "missing", "example-only"]),
+  parentReachable: z.boolean().optional(),
+  error: z.string().optional(),
+});
+
 export const bosContract = oc.router({
   dev: oc.route({ method: "POST", path: "/dev" }).input(DevOptionsSchema).output(DevResultSchema),
   start: oc
@@ -193,6 +246,15 @@ export const bosContract = oc.router({
     .route({ method: "POST", path: "/init" })
     .input(InitOptionsSchema)
     .output(InitResultSchema),
+  sync: oc
+    .route({ method: "POST", path: "/sync" })
+    .input(SyncOptionsSchema)
+    .output(SyncResultSchema),
+  upgrade: oc
+    .route({ method: "POST", path: "/upgrade" })
+    .input(UpgradeOptionsSchema)
+    .output(UpgradeResultSchema),
+  status: oc.route({ method: "GET", path: "/status" }).output(StatusResultSchema),
 });
 
 export type DevOptions = z.infer<typeof DevOptionsSchema>;
@@ -211,3 +273,8 @@ export type KeyPublishOptions = z.infer<typeof KeyPublishOptionsSchema>;
 export type KeyPublishResult = z.infer<typeof KeyPublishResultSchema>;
 export type InitOptions = z.infer<typeof InitOptionsSchema>;
 export type InitResult = z.infer<typeof InitResultSchema>;
+export type SyncOptions = z.infer<typeof SyncOptionsSchema>;
+export type SyncResult = z.infer<typeof SyncResultSchema>;
+export type UpgradeOptions = z.infer<typeof UpgradeOptionsSchema>;
+export type UpgradeResult = z.infer<typeof UpgradeResultSchema>;
+export type StatusResult = z.infer<typeof StatusResultSchema>;