everything-dev 1.8.13 → 1.9.1

package/src/api-contract.ts

@@ -22,6 +22,11 @@ export interface ApiPluginManifest {
       sha256?: string;
     };
   };
+  additionalExports?: Array<{
+    path: string;
+    exports: string[];
+    sha256?: string;
+  }>;
 }
 
 interface ContractSource {
@@ -136,6 +141,51 @@ async function remoteContractSource(opts: {
   };
 }
 
+async function fetchAuthExportTypes(opts: {
+  baseUrl: string;
+  runtimeDir: string;
+  manifest: ApiPluginManifest;
+}): Promise<string | null> {
+  if (!opts.manifest.additionalExports || opts.manifest.additionalExports.length === 0) {
+    return null;
+  }
+
+  const authExportEntry = opts.manifest.additionalExports.find(
+    (entry) => entry.path.includes("auth-export") || entry.path.endsWith("auth-export.d.ts"),
+  );
+
+  if (!authExportEntry) {
+    return null;
+  }
+
+  const exportUrl = `${trimTrailingSlash(opts.baseUrl)}/${authExportEntry.path.replace(/^\.\//, "")}`;
+  const response = await fetch(exportUrl);
+  if (!response.ok) {
+    console.warn(`[API Contract] Failed to fetch auth export types: ${response.status}`);
+    return null;
+  }
+
+  const content = await response.text();
+  if (authExportEntry.sha256 && authExportEntry.sha256 !== sha256(content)) {
+    console.warn("[API Contract] Auth export types checksum mismatch");
+    return null;
+  }
+
+  const generatedPath = join(opts.runtimeDir, "auth", "auth-export.d.ts");
+  mkdirSync(dirname(generatedPath), { recursive: true });
+  writeFileIfChanged(generatedPath, content);
+
+  return generatedPath;
+}
+
+function writeAuthTypesGen(configDir: string, authExportPath: string) {
+  const authTypesPath = join(configDir, "ui", "src", "auth-types.gen.ts");
+  const importPath = toImportPath(authTypesPath, authExportPath);
+  const content = `export type { createAuthInstance } from "${importPath}";\n`;
+  mkdirSync(dirname(authTypesPath), { recursive: true });
+  writeFileIfChanged(authTypesPath, content);
+}
+
 async function resolveContractSource(opts: {
   configDir: string;
   runtimeDir: string;
@@ -202,6 +252,7 @@ function writeGeneratedFiles(opts: {
   sources: ContractSource[];
   pluginKeys: string[];
   authSource: ContractSource | null;
+  authExportPath?: string | null;
 }) {
   const baseSource = opts.sources.find((source) => source.key === "api");
   const pluginSources = opts.pluginKeys
@@ -245,6 +296,7 @@ function writeGeneratedFiles(opts: {
   writeFileIfChanged(uiContractPath, `${uiLines.join("\n")}\n`);
 
   // --- Generate api/src/plugins-client.gen.ts ---
+  // Includes both plugin contracts AND auth as a unified PluginsClient type
   const pluginsClientPath = join(opts.configDir, "api", "src", "plugins-client.gen.ts");
   const pluginsClientLines: string[] = [];
 
@@ -255,6 +307,13 @@ function writeGeneratedFiles(opts: {
     );
   }
 
+  if (opts.authSource) {
+    const authImportPath = toImportPath(pluginsClientPath, opts.authSource.sourceFilePath);
+    pluginsClientLines.push(
+      `import type { ContractType as ${opts.authSource.importName} } from "${authImportPath}";`,
+    );
+  }
+
   pluginsClientLines.push(
     'import type { ContractRouterClient, AnyContractRouter } from "@orpc/contract";',
   );
@@ -263,11 +322,16 @@ function writeGeneratedFiles(opts: {
   );
   pluginsClientLines.push("");
 
-  if (pluginSources.length === 0) {
+  const allPluginSources = [...pluginSources];
+  if (opts.authSource) {
+    allPluginSources.push({ ...opts.authSource, key: "auth" });
+  }
+
+  if (allPluginSources.length === 0) {
     pluginsClientLines.push("export type PluginsClient = Record<string, never>;");
   } else {
     pluginsClientLines.push("export type PluginsClient = {");
-    for (const source of pluginSources) {
+    for (const source of allPluginSources) {
       const key = /^[$A-Z_][0-9A-Z_$]*$/i.test(source.key)
         ? source.key
         : JSON.stringify(source.key);
@@ -279,26 +343,9 @@ function writeGeneratedFiles(opts: {
   mkdirSync(dirname(pluginsClientPath), { recursive: true });
   writeFileIfChanged(pluginsClientPath, `${pluginsClientLines.join("\n")}\n`);
 
-  // --- Generate api/src/auth-client.gen.ts ---
-  if (opts.authSource) {
-    const authClientPath = join(opts.configDir, "api", "src", "auth-client.gen.ts");
-    const authClientLines: string[] = [];
-
-    const importPath = toImportPath(authClientPath, opts.authSource.sourceFilePath);
-    authClientLines.push(
-      `import type { ContractType as ${opts.authSource.importName} } from "${importPath}";`,
-    );
-    authClientLines.push(
-      'import type { ContractRouterClient, AnyContractRouter } from "@orpc/contract";',
-    );
-    authClientLines.push(
-      "type ClientFactory<C extends AnyContractRouter> = (context?: Record<string, unknown>) => ContractRouterClient<C>;",
-    );
-    authClientLines.push("");
-    authClientLines.push(`export type AuthClient = ClientFactory<${opts.authSource.importName}>;`);
-
-    mkdirSync(dirname(authClientPath), { recursive: true });
-    writeFileIfChanged(authClientPath, `${authClientLines.join("\n")}\n`);
+  // --- Generate ui/src/auth-types.gen.ts ---
+  if (opts.authExportPath) {
+    writeAuthTypesGen(opts.configDir, opts.authExportPath);
   }
 
   return uiContractPath;
@@ -322,6 +369,7 @@ export async function syncApiContractBridge(opts: {
   let manifest: ApiPluginManifest | null = null;
   let generatedPath: string | null = null;
   let authSource: ContractSource | null = null;
+  let authExportPath: string | null = null;
 
   const baseSource = await resolveContractSource({
     configDir: opts.configDir,
@@ -347,6 +395,30 @@ export async function syncApiContractBridge(opts: {
     if (authSource.generatedPath) {
       generatedPath = authSource.generatedPath;
     }
+
+    // Fetch auth additional exports (auth-export.d.ts) for remote auth
+    if (opts.runtimeConfig.auth.url && opts.runtimeConfig.auth.source !== "local") {
+      try {
+        const authManifest = await fetchApiPluginManifest(opts.runtimeConfig.auth.url);
+        const fetchedAuthExportPath = await fetchAuthExportTypes({
+          baseUrl: opts.runtimeConfig.auth.url,
+          runtimeDir,
+          manifest: authManifest,
+        });
+        if (fetchedAuthExportPath) {
+          authExportPath = fetchedAuthExportPath;
+        }
+      } catch (error) {
+        console.warn(
+          `[API Contract] Failed to fetch auth additional exports: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+
+    // Fallback to local auth export source if remote fetch failed or auth is local
+    if (!authExportPath) {
+      authExportPath = join(opts.configDir, "plugins", "auth", "src", "auth-export.ts");
+    }
   }
 
   for (const [key, plugin] of pluginEntries) {
@@ -377,6 +449,7 @@ export async function syncApiContractBridge(opts: {
     sources,
     pluginKeys: allPluginKeys,
     authSource,
+    authExportPath,
   });
 
   if (opts.runtimeConfig.api.source !== "local") {

package/src/cli/init.ts

@@ -399,11 +399,11 @@ export async function personalizeConfig(
       rewrite("start", "packages/everything-dev/cli.js", "node_modules/.bin/bos");
 
       if (scripts.postinstall) {
-        delete scripts.postinstall;
+        scripts.postinstall = "bos types gen";
       }
       if (scripts.typecheck) {
         scripts.typecheck = scripts.typecheck
-          .replace("bun run sync:api-contract && ", "")
+          .replace("bun run types:gen && ", "")
           .replace(/bun run --cwd packages\/everything-dev typecheck & ?/, "");
         if (!opts.withHost) {
           scripts.typecheck = scripts.typecheck.replace(/bun run --cwd host tsc --noEmit & ?/, "");
@@ -456,15 +456,6 @@ export async function personalizeConfig(
     writeFileSync(genContractPath, `export type ApiContract = Record<string, never>;\n`);
   }
 
-  const authClientGenPath = join(destination, "api", "src", "auth-client.gen.ts");
-  if (!existsSync(authClientGenPath)) {
-    mkdirSync(dirname(authClientGenPath), { recursive: true });
-    writeFileSync(
-      authClientGenPath,
-      `import type { ContractRouterClient, AnyContractRouter } from "@orpc/contract";\ntype ClientFactory<C extends AnyContractRouter> = (context?: Record<string, unknown>) => ContractRouterClient<C>;\nexport type AuthClient = ClientFactory<any>;\n`,
-    );
-  }
-
   const pluginsClientGenPath = join(destination, "api", "src", "plugins-client.gen.ts");
   if (!existsSync(pluginsClientGenPath)) {
     mkdirSync(dirname(pluginsClientGenPath), { recursive: true });
@@ -473,6 +464,12 @@ export async function personalizeConfig(
       `import type { ContractRouterClient, AnyContractRouter } from "@orpc/contract";\ntype ClientFactory<C extends AnyContractRouter> = (context?: Record<string, unknown>) => ContractRouterClient<C>;\nexport type PluginsClient = Record<string, never>;\n`,
     );
   }
+
+  const authTypesGenPath = join(destination, "ui", "src", "auth-types.gen.ts");
+  if (!existsSync(authTypesGenPath)) {
+    mkdirSync(dirname(authTypesGenPath), { recursive: true });
+    writeFileSync(authTypesGenPath, `export type { createAuthInstance } from "better-auth";\n`);
+  }
 }
 
 export async function runBunInstall(destination: string): Promise<void> {

package/src/cli.ts

@@ -46,6 +46,34 @@ function formatTimeAgo(isoTimestamp: string): string {
   return isoTimestamp.split("T")[0] ?? isoTimestamp;
 }
 
+async function warnIfOutdated(client: any, command: string): Promise<void> {
+  if (!["dev", "build", "start"].includes(command)) return;
+
+  try {
+    const status = await client.status();
+    if (status.status === "error" || !status.packages) return;
+
+    const outdated = status.packages.filter(
+      (p: { name: string; installed?: string; latest?: string }) =>
+        p.installed && p.latest && p.installed !== p.latest,
+    );
+
+    if (outdated.length === 0) return;
+
+    console.log();
+    console.log(colors.yellow(`  ! Outdated packages detected:`));
+    for (const pkg of outdated) {
+      console.log(colors.dim(`    ${pkg.name}  ${pkg.installed} → ${pkg.latest}`));
+    }
+    console.log(
+      colors.dim(`    Run ${colors.cyan("bos upgrade")} to update packages and sync template files.`),
+    );
+    console.log();
+  } catch {
+    // silently ignore if status check fails
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -87,6 +115,8 @@ async function main() {
 
   const client = plugin.createClient();
 
+  await warnIfOutdated(client, command);
+
   try {
     const input = parseCommandInput(descriptor, commandArgs);
     const result = await (client as any)[descriptor.key](input);
@@ -310,6 +340,38 @@ async function main() {
       return;
     }
 
+    if (descriptor.key === "typesGen") {
+      console.log();
+      if (result.status === "error") {
+        console.error(`[CLI] ${result.error || "Unknown error"}`);
+        process.exit(1);
+      }
+      console.log(colors.green(`${icons.ok} Types generated`));
+      if (result.source) {
+        console.log(
+          `  ${colors.dim("Mode:")} ${result.source === "remote" ? colors.cyan("remote") : colors.dim("local")}`,
+        );
+      }
+      if (result.generated.length > 0) {
+        console.log(`  ${colors.dim("Generated:")}`);
+        for (const f of result.generated) console.log(`    ${colors.dim(f)}`);
+      }
+      if (result.fetched.length > 0) {
+        console.log(`  ${colors.dim("Fetched from remote:")}`);
+        for (const url of result.fetched) console.log(`    ${colors.dim(url)}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`  ${colors.dim("Skipped (local):")}`);
+        for (const s of result.skipped) console.log(`    ${colors.dim(s)}`);
+      }
+      if (result.failed.length > 0) {
+        console.log(`  ${colors.yellow("Failed:")}`);
+        for (const f of result.failed) console.log(`    ${colors.error(f)}`);
+      }
+      console.log();
+      return;
+    }
+
     if (result?.status === "error") {
       console.error(`[CLI] ${result.error || "Unknown error"}`);
       process.exit(1);

package/src/contract.meta.ts

@@ -121,6 +121,15 @@ export const cliCommandMeta = {
       noSync: { description: "Only upgrade packages, skip template sync" },
     },
   },
+  typesGen: {
+    commandPath: ["types", "gen"],
+    summary: "Generate type definitions from configured API and plugin contracts",
+    interactive: false,
+    fields: {
+      env: { description: "Environment: development (default) or production" },
+      dryRun: { description: "Preview what would be fetched without writing files" },
+    },
+  },
   status: {
     commandPath: ["status"],
     summary: "Show project health, versions, and update availability",

package/src/contract.ts

@@ -221,6 +221,21 @@ export const StatusResultSchema = z.object({
   error: z.string().optional(),
 });
 
+export const TypesGenOptionsSchema = z.object({
+  env: z.enum(["development", "production"]).optional(),
+  dryRun: z.boolean().default(false),
+});
+
+export const TypesGenResultSchema = z.object({
+  status: z.enum(["success", "error"]),
+  generated: z.array(z.string()),
+  fetched: z.array(z.string()),
+  skipped: z.array(z.string()),
+  failed: z.array(z.string()),
+  source: z.enum(["local", "remote"]).optional(),
+  error: z.string().optional(),
+});
+
 export const bosContract = oc.router({
   dev: oc.route({ method: "POST", path: "/dev" }).input(DevOptionsSchema).output(DevResultSchema),
   start: oc
@@ -266,6 +281,10 @@ export const bosContract = oc.router({
     .input(UpgradeOptionsSchema)
     .output(UpgradeResultSchema),
   status: oc.route({ method: "GET", path: "/status" }).output(StatusResultSchema),
+  typesGen: oc
+    .route({ method: "POST", path: "/types/gen" })
+    .input(TypesGenOptionsSchema)
+    .output(TypesGenResultSchema),
 });
 
 export type DevOptions = z.infer<typeof DevOptionsSchema>;
@@ -289,3 +308,5 @@ 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>;
+export type TypesGenOptions = z.infer<typeof TypesGenOptionsSchema>;
+export type TypesGenResult = z.infer<typeof TypesGenResultSchema>;

package/src/orchestrator.ts

@@ -1,4 +1,3 @@
-import { createConnection } from "node:net";
 import { Command } from "@effect/platform";
 import type { ExitCode } from "@effect/platform/CommandExecutor";
 import { Deferred, Effect, Option, Ref, Stream } from "effect";
@@ -66,24 +65,6 @@ const probeHttpOk = (url: string, timeoutMs = 400) =>
     catch: () => false,
   });
 
-const probeTcpOpen = (port: number, timeoutMs = 250) =>
-  Effect.async<boolean>((resume) => {
-    const socket = createConnection({ host: "127.0.0.1", port });
-    const timer = setTimeout(() => {
-      socket.destroy();
-      resume(Effect.succeed(false));
-    }, timeoutMs);
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      socket.destroy();
-      resume(Effect.succeed(true));
-    });
-    socket.once("error", () => {
-      clearTimeout(timer);
-      resume(Effect.succeed(false));
-    });
-  });
-
 const detectStatus = (
   line: string,
   descriptor: ServiceDescriptor,

package/src/plugin.ts

@@ -40,6 +40,7 @@ import {
   type PublishOptions,
   type StartOptions,
   type SyncOptions,
+  type TypesGenOptions,
   type UpgradeOptions,
 } from "./contract";
 import { devApp, startApp } from "./dev-session";
@@ -94,7 +95,7 @@ function ensureEnvFile(configDir: string): void {
     .join("\n");
 
   writeFileSync(envPath, updated);
-  console.log(`[CLI] Created .env from .env.example with generated BETTER_AUTH_SECRET`);
+  p.log.info(`Created .env from .env.example with generated BETTER_AUTH_SECRET`);
 }
 
 const buildCommands: Record<string, { cmd: string; args: string[] }> = {
@@ -256,8 +257,11 @@ function listPluginAttachments(config: BosConfig | null) {
     .sort((a, b) => a.key.localeCompare(b.key));
 }
 
-async function refreshApiContractBridge(configDir: string): Promise<void> {
-  const refreshed = await loadConfig({ cwd: configDir, env: "development" });
+async function refreshApiContractBridge(
+  configDir: string,
+  env: "development" | "production" = "development",
+): Promise<void> {
+  const refreshed = await loadConfig({ cwd: configDir, env });
   if (!refreshed) return;
 
   await syncApiContractBridge({
@@ -1467,6 +1471,116 @@ export default createPlugin({
       }
     }),
 
+    typesGen: builder.typesGen.handler(async ({ input }: { input: TypesGenOptions }) => {
+      try {
+        const configPath = findConfigPath();
+        if (!configPath) {
+          return {
+            status: "error" as const,
+            generated: [],
+            fetched: [],
+            skipped: [],
+            failed: [],
+            error: "No bos.config.json found in current directory",
+          };
+        }
+
+        const projectDir = resolve(dirname(configPath));
+        const env =
+          input.env ?? (process.env.NODE_ENV === "production" ? "production" : "development");
+
+        const refreshed = await loadConfig({ cwd: projectDir, env });
+        if (!refreshed) {
+          return {
+            status: "error" as const,
+            generated: [],
+            fetched: [],
+            skipped: [],
+            failed: [],
+            error: "Failed to load bos.config.json",
+          };
+        }
+
+        if (input.dryRun) {
+          const pluginEntries = Object.entries(refreshed.runtime.plugins ?? {});
+          const fetched: string[] = [];
+          const skipped: string[] = [];
+
+          if (refreshed.runtime.api.source !== "local") {
+            fetched.push(refreshed.runtime.api.url);
+          } else {
+            skipped.push("api (local)");
+          }
+
+          if (refreshed.runtime.auth) {
+            if (refreshed.runtime.auth.source !== "local") {
+              fetched.push(refreshed.runtime.auth.url);
+            } else {
+              skipped.push("auth (local)");
+            }
+          }
+
+          for (const [key, plugin] of pluginEntries) {
+            if (plugin.url && plugin.source !== "local") {
+              fetched.push(plugin.url);
+            } else if (plugin.localPath) {
+              skipped.push(`${key} (local)`);
+            }
+          }
+
+          return {
+            status: "success" as const,
+            generated: [
+              "ui/src/api-contract.gen.ts",
+              "ui/src/auth-types.gen.ts",
+              "api/src/plugins-client.gen.ts",
+              "api/src/auth-client.gen.ts",
+            ],
+            fetched,
+            skipped,
+            failed: [],
+            source: refreshed.runtime.api.source,
+          };
+        }
+
+        const result = await syncApiContractBridge({
+          configDir: projectDir,
+          runtimeConfig: refreshed.runtime,
+          apiBaseUrl: refreshed.runtime.api.url,
+        });
+
+        const generated = [
+          "ui/src/api-contract.gen.ts",
+          "api/src/plugins-client.gen.ts",
+          "api/src/auth-client.gen.ts",
+        ];
+        if (
+          refreshed.runtime.auth &&
+          (refreshed.runtime.auth.source !== "local" || refreshed.runtime.auth.localPath)
+        ) {
+          generated.push("ui/src/auth-types.gen.ts");
+        }
+
+        return {
+          status: "success" as const,
+          generated,
+          fetched: result.source === "remote" ? [refreshed.runtime.api.url] : [],
+          skipped: result.source === "local" ? ["api (local)"] : [],
+          failed: [],
+          source: result.source,
+        };
+      } catch (error) {
+        return {
+          status: "error" as const,
+          generated: [],
+          fetched: [],
+          skipped: [],
+          failed: [],
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
     status: builder.status.handler(async () => {
       try {
         const configPath = findConfigPath();

package/src/scripts/sync-api-contract.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env bun
-
-import { dirname } from "node:path";
-import { syncApiContractBridge } from "../api-contract";
-import { loadConfig } from "../config";
-
-async function main() {
-  const result = await loadConfig({ cwd: process.cwd(), env: "development" });
-  if (!result) {
-    throw new Error("No bos.config.json found");
-  }
-
-  const configDir = dirname(result.source.path);
-  await syncApiContractBridge({
-    configDir,
-    runtimeConfig: result.runtime,
-    apiBaseUrl: result.runtime.api.url,
-  });
-}
-
-main().catch((error) => {
-  console.error("[sync-api-contract]", error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});