everything-dev 1.8.13 → 1.9.0

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