everything-dev 1.8.12 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "everything-dev",
-  "version": "1.8.12",
+  "version": "1.9.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -155,7 +155,7 @@
     "@orpc/zod": "^1.13.4",
     "chalk": "^5.6.2",
     "effect": "^3.21.0",
-    "every-plugin": "^2.5.3",
+    "every-plugin": "^2.5.4",
     "glob": "^13.0.6",
     "gradient-string": "^3.0.0",
     "hono": "^4.7.11",

package/skills/dev-workflow/SKILL.md

@@ -53,10 +53,10 @@ The orchestrator:
 
 ## Contract Sync & Type Generation
 
-Plugin types are auto-generated from `bos.config.json` via `bun run sync:api-contract`:
+Plugin types are auto-generated from `bos.config.json` via `bos types gen`:
 
 ```bash
-bun run sync:api-contract   # Regenerate ui/src/api-contract.gen.ts and api/src/plugins-client.gen.ts
+bos types gen   # Regenerate ui/src/api-contract.gen.ts and api/src/plugins-client.gen.ts
 ```
 
 **When it auto-runs:**
@@ -73,7 +73,7 @@ bun run sync:api-contract   # Regenerate ui/src/api-contract.gen.ts and api/src/
 
 **Source of truth:** `bos.config.json`. If a plugin is listed there, its routes appear on `ApiContract`. If removed, TypeScript catches stale usage.
 
-**After hand-editing `bos.config.json`:** Run `bun run sync:api-contract` or restart `bos dev` to pick up changes.
+**After hand-editing `bos.config.json`:** Run `bos types gen` or restart `bos dev` to pick up changes.
 
 ## Runtime Config Loading
 

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

@@ -309,6 +309,19 @@ export async function personalizeConfig(
 
     if (isInit && config.app && typeof config.app === "object") {
       const app = config.app as Record<string, unknown>;
+
+      const authClientPath = join(destination, "ui", "src", "lib", "auth-client.ts");
+      if (existsSync(authClientPath)) {
+        const authClientContent = readFileSync(authClientPath, "utf-8")
+          .split("\n")
+          .filter(
+            (line) =>
+              !line.includes("inferAdditionalFields") && !line.includes("createAuthInstance"),
+          )
+          .join("\n");
+        writeFileSync(authClientPath, authClientContent);
+      }
+
       for (const entryKey of Object.keys(app)) {
         const entry = app[entryKey];
         if (entry && typeof entry === "object") {
@@ -385,14 +398,16 @@ export async function personalizeConfig(
       rewrite("publish", "packages/everything-dev/cli.js", "node_modules/.bin/bos");
       rewrite("start", "packages/everything-dev/cli.js", "node_modules/.bin/bos");
 
-      if (scripts["sync:api-contract"]) {
-        delete scripts["sync:api-contract"];
-      }
       if (scripts.postinstall) {
-        delete scripts.postinstall;
+        scripts.postinstall = "bos types gen";
       }
-      if (scripts.typecheck?.includes("sync:api-contract")) {
-        scripts.typecheck = scripts.typecheck.replace("bun run sync:api-contract && ", "");
+      if (scripts.typecheck) {
+        scripts.typecheck = scripts.typecheck
+          .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 & ?/, "");
+        }
       }
     }
 
@@ -414,6 +429,25 @@ export async function personalizeConfig(
     writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
   }
 
+  const apiTsConfigPath = join(destination, "api", "tsconfig.json");
+  if (existsSync(apiTsConfigPath)) {
+    const apiTsConfig = JSON.parse(readFileSync(apiTsConfigPath, "utf-8")) as {
+      files?: string[];
+      [key: string]: unknown;
+    };
+    if (apiTsConfig.files) {
+      const validFiles = apiTsConfig.files.filter((f) => existsSync(join(destination, "api", f)));
+      if (validFiles.length !== apiTsConfig.files.length) {
+        if (validFiles.length === 0) {
+          delete apiTsConfig.files;
+        } else {
+          apiTsConfig.files = validFiles;
+        }
+        writeFileSync(apiTsConfigPath, `${JSON.stringify(apiTsConfig, null, 2)}\n`);
+      }
+    }
+  }
+
   await resolveWorkspaceRefs(destination, opts.workspaceOpts);
 
   const genContractPath = join(destination, "ui", "src", "api-contract.gen.ts");
@@ -421,6 +455,21 @@ export async function personalizeConfig(
     mkdirSync(dirname(genContractPath), { recursive: true });
     writeFileSync(genContractPath, `export type ApiContract = Record<string, never>;\n`);
   }
+
+  const pluginsClientGenPath = join(destination, "api", "src", "plugins-client.gen.ts");
+  if (!existsSync(pluginsClientGenPath)) {
+    mkdirSync(dirname(pluginsClientGenPath), { recursive: true });
+    writeFileSync(
+      pluginsClientGenPath,
+      `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

@@ -310,6 +310,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/dev-session.ts

@@ -251,6 +251,11 @@ const runApp = (
     Effect.provide(ServiceDescriptorMapLive(services)),
     Effect.provide(DevRuntimeConfigLive(runtimeConfig)),
     Effect.provide(NodeContext.layer),
+    Effect.catchAllDefect((defect) =>
+      Effect.sync(() => {
+        console.error("[Dev] Unhandled defect in orchestrator:", defect);
+      }),
+    ),
   );
 
   const handleSignal = () => {

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";
@@ -10,6 +9,14 @@ import {
 } from "./service-descriptor";
 import type { RuntimeConfig } from "./types";
 
+process.on("unhandledRejection", (reason) => {
+  console.error("[Orchestrator] Unhandled rejection:", reason);
+});
+
+process.on("uncaughtException", (err) => {
+  console.error("[Orchestrator] Uncaught exception:", err);
+});
+
 export interface ProcessCallbacks {
   onStatus: (name: string, status: ProcessStatus, message?: string) => void;
   onLog: (name: string, line: string, isError?: boolean) => void;
@@ -55,26 +62,8 @@ const probeHttpOk = (url: string, timeoutMs = 400) =>
         clearTimeout(timer);
       }
     },
-    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));
-    });
-  });
+  catch: () => false,
+});
 
 const detectStatus = (
   line: string,

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";
@@ -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);
-});