everything-dev 0.0.15 → 0.0.17

package/src/plugin.ts

@@ -3,6 +3,7 @@ import { Effect } from "every-plugin/effect";
 import { z } from "every-plugin/zod";
 import { Graph } from "near-social-js";
 
+import { createProcessRegistry } from "./lib/process-registry";
 import {
   type AppConfig,
   type BosConfig as BosConfigType,
@@ -34,6 +35,7 @@ import {
   verifyNovaCredentials
 } from "./lib/nova";
 import { type AppOrchestrator, startApp } from "./lib/orchestrator";
+import { syncFiles } from "./lib/sync";
 import { run } from "./utils/run";
 import { colors, icons } from "./utils/theme";
 
@@ -54,6 +56,27 @@ function getGatewayDomain(config: BosConfigType): string {
   throw new Error("bos.config.json must have a 'gateway' field with production URL");
 }
 
+function getAccountForNetwork(config: BosConfigType, network: "mainnet" | "testnet"): string {
+  if (network === "testnet") {
+    if (!config.testnet) {
+      throw new Error("bos.config.json must have a 'testnet' field to use testnet network");
+    }
+    return config.testnet;
+  }
+  return config.account;
+}
+
+function getSocialContract(network: "mainnet" | "testnet"): string {
+  return network === "testnet" ? "v1.social08.testnet" : "social.near";
+}
+
+function getSocialExplorerUrl(network: "mainnet" | "testnet", path: string): string {
+  const baseUrl = network === "testnet" 
+    ? "https://test.near.social" 
+    : "https://near.social";
+  return `${baseUrl}/${path}`;
+}
+
 function buildSocialSetArgs(account: string, gatewayDomain: string, config: BosConfigType): object {
   return {
     data: {
@@ -201,6 +224,7 @@ export default createPlugin({
         env,
         description,
         appConfig,
+        bosConfig: deps.bosConfig ?? undefined,
         port: input.port,
         interactive: input.interactive,
       };
@@ -236,7 +260,9 @@ export default createPlugin({
             }
             if (typeof current === "string") {
               remoteConfig = JSON.parse(current) as BosConfigType;
-              setConfig(remoteConfig);
+              const configFilePath = `${process.cwd()}/bos.config.json`;
+              await Bun.write(configFilePath, JSON.stringify(remoteConfig, null, 2));
+              setConfig(remoteConfig, process.cwd());
             }
           }
         } catch (error) {
@@ -297,6 +323,7 @@ export default createPlugin({
           ui: "remote",
           api: "remote",
         },
+        bosConfig: config,
         port,
         interactive: input.interactive,
         noLogs: true,
@@ -312,6 +339,7 @@ export default createPlugin({
 
     serve: builder.serve.handler(async ({ input }) => {
       const port = input.port;
+      
       return {
         status: "serving" as const,
         url: `http://localhost:${port}`,
@@ -381,7 +409,7 @@ export default createPlugin({
     }),
 
     publish: builder.publish.handler(async ({ input: publishInput }) => {
-      const { configDir, bosConfig, nearPrivateKey } = deps;
+      const { bosConfig, nearPrivateKey } = deps;
 
       if (!bosConfig) {
         return {
@@ -392,45 +420,49 @@ export default createPlugin({
         };
       }
 
-      const gatewayDomain = getGatewayDomain(bosConfig);
-      const socialPath = `${bosConfig.account}/bos/gateways/${gatewayDomain}/bos.config.json`;
+      const network = publishInput.network;
 
-      const publishEffect = Effect.gen(function* () {
-        yield* ensureNearCli;
+      try {
+        const account = getAccountForNetwork(bosConfig, network);
+        const gatewayDomain = getGatewayDomain(bosConfig);
+        const socialContract = getSocialContract(network);
+        const socialPath = `${account}/bos/gateways/${gatewayDomain}/bos.config.json`;
 
-        const bosEnv = yield* loadBosEnv;
-        const privateKey = nearPrivateKey || bosEnv.NEAR_PRIVATE_KEY;
+        const publishEffect = Effect.gen(function* () {
+          yield* ensureNearCli;
+
+          const bosEnv = yield* loadBosEnv;
+          const privateKey = nearPrivateKey || bosEnv.NEAR_PRIVATE_KEY;
+
+          const socialArgs = buildSocialSetArgs(account, gatewayDomain, bosConfig);
+          const argsBase64 = Buffer.from(JSON.stringify(socialArgs)).toString("base64");
+
+          if (publishInput.dryRun) {
+            return {
+              status: "dry-run" as const,
+              txHash: "",
+              registryUrl: getSocialExplorerUrl(network, socialPath),
+            };
+          }
 
-        const socialArgs = buildSocialSetArgs(bosConfig.account, gatewayDomain, bosConfig);
-        const argsBase64 = Buffer.from(JSON.stringify(socialArgs)).toString("base64");
+          const result = yield* executeTransaction({
+            account,
+            contract: socialContract,
+            method: "set",
+            argsBase64,
+            network,
+            privateKey,
+            gas: "300Tgas",
+            deposit: "0.05NEAR",
+          });
 
-        if (publishInput.dryRun) {
           return {
-            status: "dry-run" as const,
-            txHash: "",
-            registryUrl: `https://near.social/${socialPath}`,
+            status: "published" as const,
+            txHash: result.txHash || "unknown",
+            registryUrl: getSocialExplorerUrl(network, socialPath),
           };
-        }
-
-        const result = yield* executeTransaction({
-          account: bosConfig.account,
-          contract: "social.near",
-          method: "set",
-          argsBase64,
-          network: publishInput.network,
-          privateKey,
-          gas: "300Tgas",
-          deposit: "0.05NEAR",
         });
 
-        return {
-          status: "published" as const,
-          txHash: result.txHash || "unknown",
-          registryUrl: `https://near.social/${socialPath}`,
-        };
-      });
-
-      try {
         return await Effect.runPromise(publishEffect);
       } catch (error) {
         return {
@@ -456,7 +488,16 @@ export default createPlugin({
         gateway: "near-everything/every-plugin/demo/gateway",
       };
 
-      const template = input.template || deps.bosConfig?.create?.[input.type] || DEFAULT_TEMPLATES[input.type];
+      const getTemplate = (): string => {
+        if (input.template) return input.template;
+        if (input.type === "project") {
+          return deps.bosConfig?.template || DEFAULT_TEMPLATES.project;
+        }
+        const appConfig = deps.bosConfig?.app[input.type] as { template?: string } | undefined;
+        return appConfig?.template || DEFAULT_TEMPLATES[input.type];
+      };
+
+      const template = getTemplate();
       const dest = input.type === "project" ? input.name! : input.type;
 
       try {
@@ -465,11 +506,11 @@ export default createPlugin({
         if (input.type === "project" && input.name) {
           const newConfig = {
             account: `${input.name}.near`,
+            template: DEFAULT_TEMPLATES.project,
             gateway: {
               development: "http://localhost:8787",
               production: `https://gateway.${input.name}.example.com`,
             },
-            create: DEFAULT_TEMPLATES,
             app: {
               host: {
                 title: input.name,
@@ -630,41 +671,44 @@ export default createPlugin({
         };
       }
 
-      const registerEffect = Effect.gen(function* () {
-        yield* ensureNearCli;
+      const network = input.network;
 
-        const bosEnv = yield* loadBosEnv;
-        const gatewayPrivateKey = bosEnv.GATEWAY_PRIVATE_KEY;
+      try {
+        const parentAccount = getAccountForNetwork(bosConfig, network);
+        const fullAccount = `${input.name}.${parentAccount}`;
 
-        const fullAccount = `${input.name}.${bosConfig.account}`;
-        const parentAccount = bosConfig.account;
+        const registerEffect = Effect.gen(function* () {
+          yield* ensureNearCli;
 
-        yield* createSubaccount({
-          newAccount: fullAccount,
-          parentAccount,
-          initialBalance: "0.1NEAR",
-          network: input.network,
-          privateKey: gatewayPrivateKey,
-        });
+          const bosEnv = yield* loadBosEnv;
+          const gatewayPrivateKey = bosEnv.GATEWAY_PRIVATE_KEY;
 
-        const novaConfig = yield* getNovaConfig;
-        const nova = createNovaClient(novaConfig);
+          yield* createSubaccount({
+            newAccount: fullAccount,
+            parentAccount,
+            initialBalance: "0.1NEAR",
+            network,
+            privateKey: gatewayPrivateKey,
+          });
 
-        yield* registerSecretsGroup(nova, fullAccount, parentAccount);
+          const novaConfig = yield* getNovaConfig;
+          const nova = createNovaClient(novaConfig);
 
-        return {
-          status: "registered" as const,
-          account: fullAccount,
-          novaGroup: getSecretsGroupId(fullAccount),
-        };
-      });
+          yield* registerSecretsGroup(nova, fullAccount, parentAccount);
+
+          return {
+            status: "registered" as const,
+            account: fullAccount,
+            novaGroup: getSecretsGroupId(fullAccount),
+          };
+        });
 
-      try {
         return await Effect.runPromise(registerEffect);
       } catch (error) {
+        const parentAccount = network === "testnet" ? bosConfig.testnet : bosConfig.account;
         return {
           status: "error" as const,
-          account: `${input.name}.${bosConfig.account}`,
+          account: `${input.name}.${parentAccount || bosConfig.account}`,
           error: error instanceof Error ? error.message : "Unknown error",
         };
       }
@@ -1145,7 +1189,7 @@ export default createPlugin({
       }
     }),
 
-    depsSync: builder.depsSync.handler(async ({ input }) => {
+    filesSync: builder.filesSync.handler(async ({ input }) => {
       const { configDir, bosConfig } = deps;
 
       if (!bosConfig) {
@@ -1156,62 +1200,26 @@ export default createPlugin({
         };
       }
 
-      const category = input.category;
-      const sharedDeps = bosConfig.shared?.[category];
-
-      if (!sharedDeps || Object.keys(sharedDeps).length === 0) {
-        return {
-          status: "error" as const,
-          synced: [],
-          error: `No shared.${category} dependencies found in bos.config.json`,
-        };
-      }
-
-      try {
-        const rootPkgPath = `${configDir}/package.json`;
-        const rootPkg = await Bun.file(rootPkgPath).json() as {
-          workspaces?: { packages?: string[]; catalog?: Record<string, string> };
-        };
-
-        if (!rootPkg.workspaces) {
-          rootPkg.workspaces = {};
-        }
-        if (!rootPkg.workspaces.catalog) {
-          rootPkg.workspaces.catalog = {};
-        }
-
-        const synced: string[] = [];
-
-        for (const [name, config] of Object.entries(sharedDeps)) {
-          const version = (config as { requiredVersion?: string }).requiredVersion;
-          if (version) {
-            const cleanVersion = version.replace(/^[\^~]/, "");
-            rootPkg.workspaces.catalog[name] = cleanVersion;
-            synced.push(name);
-          }
-        }
+      const rootPkgPath = `${configDir}/package.json`;
+      const rootPkg = await Bun.file(rootPkgPath).json() as {
+        workspaces?: { catalog?: Record<string, string> };
+      };
+      const catalog = rootPkg.workspaces?.catalog ?? {};
 
-        await Bun.write(rootPkgPath, JSON.stringify(rootPkg, null, 2));
+      const packages = input.packages || Object.keys(bosConfig.app);
 
-        if (input.install) {
-          const { execa } = await import("execa");
-          await execa("bun", ["install"], {
-            cwd: configDir,
-            stdio: "inherit",
-          });
-        }
+      const synced = await syncFiles({
+        configDir,
+        packages,
+        bosConfig,
+        catalog,
+        force: input.force,
+      });
 
-        return {
-          status: "synced" as const,
-          synced,
-        };
-      } catch (error) {
-        return {
-          status: "error" as const,
-          synced: [],
-          error: error instanceof Error ? error.message : "Unknown error",
-        };
-      }
+      return {
+        status: "synced" as const,
+        synced,
+      };
     }),
 
     sync: builder.sync.handler(async ({ input }) => {
@@ -1348,6 +1356,22 @@ export default createPlugin({
           }
         }
 
+        let filesSynced: Array<{ package: string; files: string[] }> | undefined;
+
+        if (input.files) {
+          const results = await syncFiles({
+            configDir,
+            packages: Object.keys(bosConfig.app),
+            bosConfig,
+            catalog: rootPkg.workspaces?.catalog ?? {},
+            force: input.force,
+          });
+
+          if (results.length > 0) {
+            filesSynced = results.map(r => ({ package: r.package, files: r.files }));
+          }
+        }
+
         return {
           status: "synced" as const,
           account,
@@ -1355,6 +1379,7 @@ export default createPlugin({
           hostUrl,
           catalogUpdated: true,
           packagesUpdated,
+          filesSynced,
         };
       } catch (error) {
         return {
@@ -1368,5 +1393,227 @@ export default createPlugin({
         };
       }
     }),
+
+    kill: builder.kill.handler(async ({ input }) => {
+      const killEffect = Effect.gen(function* () {
+        const registry = yield* createProcessRegistry();
+        const result = yield* registry.killAll(input.force);
+        return {
+          status: "killed" as const,
+          killed: result.killed,
+          failed: result.failed,
+        };
+      });
+
+      try {
+        return await Effect.runPromise(killEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          killed: [],
+          failed: [],
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
+    ps: builder.ps.handler(async () => {
+      const psEffect = Effect.gen(function* () {
+        const registry = yield* createProcessRegistry();
+        const processes = yield* registry.getAll();
+        return {
+          status: "listed" as const,
+          processes,
+        };
+      });
+
+      try {
+        return await Effect.runPromise(psEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          processes: [],
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
+    dockerBuild: builder.dockerBuild.handler(async ({ input }) => {
+      const { configDir, bosConfig } = deps;
+
+      const dockerEffect = Effect.gen(function* () {
+        const { execa } = yield* Effect.tryPromise({
+          try: () => import("execa"),
+          catch: (e) => new Error(`Failed to import execa: ${e}`),
+        });
+
+        const dockerfile = input.target === "development" ? "Dockerfile.dev" : "Dockerfile";
+        const imageName = bosConfig?.account?.replace(/\./g, "-") || "bos-app";
+        const tag = input.tag || (input.target === "development" ? "dev" : "latest");
+        const fullTag = `${imageName}:${tag}`;
+
+        const args = ["build", "-f", dockerfile, "-t", fullTag];
+        if (input.noCache) {
+          args.push("--no-cache");
+        }
+        args.push(".");
+
+        yield* Effect.tryPromise({
+          try: () => execa("docker", args, {
+            cwd: configDir,
+            stdio: "inherit",
+          }),
+          catch: (e) => new Error(`Docker build failed: ${e}`),
+        });
+
+        return {
+          status: "built" as const,
+          image: imageName,
+          tag: fullTag,
+        };
+      });
+
+      try {
+        return await Effect.runPromise(dockerEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          image: "",
+          tag: "",
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
+    dockerRun: builder.dockerRun.handler(async ({ input }) => {
+      const { bosConfig } = deps;
+
+      const dockerEffect = Effect.gen(function* () {
+        const { execa } = yield* Effect.tryPromise({
+          try: () => import("execa"),
+          catch: (e) => new Error(`Failed to import execa: ${e}`),
+        });
+
+        const imageName = bosConfig?.account?.replace(/\./g, "-") || "bos-app";
+        const tag = input.target === "development" ? "dev" : "latest";
+        const fullTag = `${imageName}:${tag}`;
+        const port = input.port || (input.target === "development" ? 4000 : 3000);
+
+        const args = ["run"];
+        
+        if (input.detach) {
+          args.push("-d");
+        }
+
+        args.push("-p", `${port}:${port}`);
+        args.push("-e", `PORT=${port}`);
+
+        if (input.target === "development") {
+          args.push("-e", `MODE=${input.mode}`);
+        }
+
+        if (input.env) {
+          for (const [key, value] of Object.entries(input.env)) {
+            args.push("-e", `${key}=${value}`);
+          }
+        }
+
+        if (bosConfig) {
+          args.push("-e", `BOS_ACCOUNT=${bosConfig.account}`);
+          const gateway = bosConfig.gateway as { production?: string } | string | undefined;
+          if (gateway) {
+            const domain = typeof gateway === "string" 
+              ? gateway 
+              : gateway.production?.replace(/^https?:\/\//, "") || "";
+            if (domain) {
+              args.push("-e", `GATEWAY_DOMAIN=${domain}`);
+            }
+          }
+        }
+
+        args.push(fullTag);
+
+        const result = yield* Effect.tryPromise({
+          try: () => execa("docker", args, {
+            stdio: input.detach ? "pipe" : "inherit",
+          }),
+          catch: (e) => new Error(`Docker run failed: ${e}`),
+        });
+
+        const containerId = input.detach && result.stdout ? result.stdout.trim().slice(0, 12) : "attached";
+
+        return {
+          status: "running" as const,
+          containerId,
+          url: `http://localhost:${port}`,
+        };
+      });
+
+      try {
+        return await Effect.runPromise(dockerEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          containerId: "",
+          url: "",
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
+
+    dockerStop: builder.dockerStop.handler(async ({ input }) => {
+      const { bosConfig } = deps;
+
+      const dockerEffect = Effect.gen(function* () {
+        const { execa } = yield* Effect.tryPromise({
+          try: () => import("execa"),
+          catch: (e) => new Error(`Failed to import execa: ${e}`),
+        });
+
+        const stopped: string[] = [];
+
+        if (input.containerId) {
+          yield* Effect.tryPromise({
+            try: () => execa("docker", ["stop", input.containerId!]),
+            catch: (e) => new Error(`Failed to stop container: ${e}`),
+          });
+          stopped.push(input.containerId!);
+        } else if (input.all) {
+          const imageName = bosConfig?.account?.replace(/\./g, "-") || "bos-app";
+          
+          const psResult = yield* Effect.tryPromise({
+            try: () => execa("docker", ["ps", "-q", "--filter", `ancestor=${imageName}`]),
+            catch: () => new Error("Failed to list containers"),
+          });
+
+          const containerIds = psResult.stdout.trim().split("\n").filter(Boolean);
+          
+          for (const id of containerIds) {
+            yield* Effect.tryPromise({
+              try: () => execa("docker", ["stop", id]),
+              catch: () => new Error(`Failed to stop container ${id}`),
+            }).pipe(Effect.catchAll(() => Effect.void));
+            stopped.push(id);
+          }
+        }
+
+        return {
+          status: "stopped" as const,
+          stopped,
+        };
+      });
+
+      try {
+        return await Effect.runPromise(dockerEffect);
+      } catch (error) {
+        return {
+          status: "error" as const,
+          stopped: [],
+          error: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    }),
   }),
 });
+
+

package/src/types.ts

@@ -9,6 +9,9 @@ export const HostConfigSchema = z.object({
   development: z.string(),
   production: z.string(),
   secrets: z.array(z.string()).optional(),
+  template: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  sync: z.lazy(() => SyncConfigSchema).optional(),
 });
 export type HostConfig = z.infer<typeof HostConfigSchema>;
 
@@ -21,6 +24,9 @@ export const RemoteConfigSchema = z.object({
   exposes: z.record(z.string(), z.string()).optional(),
   variables: z.record(z.string(), z.string()).optional(),
   secrets: z.array(z.string()).optional(),
+  template: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  sync: z.lazy(() => SyncConfigSchema).optional(),
 });
 export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
 
@@ -38,11 +44,18 @@ export const SharedDepConfigSchema = z.object({
 });
 export type SharedDepConfig = z.infer<typeof SharedDepConfigSchema>;
 
+export const SyncConfigSchema = z.object({
+  scripts: z.union([z.array(z.string()), z.literal(true)]).optional(),
+  dependencies: z.boolean().default(true),
+  devDependencies: z.boolean().default(true),
+});
+export type SyncConfig = z.infer<typeof SyncConfigSchema>;
+
 export const BosConfigSchema = z.object({
   account: z.string(),
+  testnet: z.string().optional(),
   gateway: GatewayConfigSchema,
-  templates: z.record(z.string(), z.string()).optional(),
-  create: z.record(z.string(), z.string()).optional(),
+  template: z.string().optional(),
   cli: z.object({
     version: z.string().optional(),
   }).optional(),