everything-dev 0.1.4 → 0.2.0

package/src/lib/process.ts

@@ -1,8 +1,8 @@
 import { Command } from "@effect/platform";
 import { Deferred, Effect, Fiber, Ref, Stream } from "every-plugin/effect";
-import { type BosConfig, getConfigDir, getPortsFromConfig, type SourceMode } from "../config";
 import type { ProcessStatus } from "../components/dev-view";
-import { loadSecretsFor } from "./secrets";
+import { type BosConfig, getConfigDir, getPortsFromConfig, type RemoteConfig, type SourceMode } from "../config";
+import type { RuntimeConfig } from "../types";
 
 export interface DevProcess {
   name: string;
@@ -68,7 +68,7 @@ export const getProcessConfig = (
   if (!base) return null;
 
   const ports = getPortsFromConfig();
-  
+
   let port: number;
   if (pkg === "host") {
     port = portOverride ?? ports.host;
@@ -157,9 +157,45 @@ const killProcessTree = (pid: number) =>
     }
   });
 
+export function buildRuntimeConfig(
+  bosConfig: BosConfig,
+  options: {
+    uiSource: SourceMode;
+    apiSource: SourceMode;
+    hostUrl: string;
+    proxy?: string;
+    env?: "development" | "production";
+  }
+): RuntimeConfig {
+  const uiConfig = bosConfig.app.ui as RemoteConfig;
+  const apiConfig = bosConfig.app.api as RemoteConfig;
+
+  return {
+    env: options.env ?? "development",
+    account: bosConfig.account,
+    hostUrl: options.hostUrl,
+    shared: (bosConfig as { shared?: { ui?: Record<string, unknown> } }).shared as RuntimeConfig["shared"],
+    ui: {
+      name: uiConfig.name,
+      url: options.uiSource === "remote" ? uiConfig.production : uiConfig.development,
+      ssrUrl: options.uiSource === "remote" ? uiConfig.ssr : undefined,
+      source: options.uiSource,
+    },
+    api: {
+      name: apiConfig.name,
+      url: options.apiSource === "remote" ? apiConfig.production : apiConfig.development,
+      source: options.apiSource,
+      proxy: options.proxy,
+      variables: apiConfig.variables,
+      secrets: apiConfig.secrets,
+    },
+  };
+}
+
 export const spawnDevProcess = (
   config: DevProcess,
-  callbacks: ProcessCallbacks
+  callbacks: ProcessCallbacks,
+  runtimeConfig?: RuntimeConfig
 ) =>
   Effect.gen(function* () {
     const configDir = getConfigDir();
@@ -169,15 +205,20 @@ export const spawnDevProcess = (
 
     callbacks.onStatus(config.name, "starting");
 
+    const envVars: Record<string, string> = {
+      ...process.env as Record<string, string>,
+      ...config.env,
+      FORCE_COLOR: "1",
+      ...(config.port > 0 ? { PORT: String(config.port) } : {}),
+    };
+
+    if (runtimeConfig && config.name === "host") {
+      envVars.BOS_RUNTIME_CONFIG = JSON.stringify(runtimeConfig);
+    }
+
     const cmd = Command.make(config.command, ...config.args).pipe(
       Command.workingDirectory(fullCwd),
-      Command.env({
-        ...process.env,
-        ...config.env,
-        BOS_CONFIG_PATH: "../bos.config.json",
-        FORCE_COLOR: "1",
-        ...(config.port > 0 ? { PORT: String(config.port) } : {}),
-      })
+      Command.env(envVars)
     );
 
     const proc = yield* Command.start(cmd);
@@ -247,13 +288,8 @@ interface ServerHandle {
   shutdown: () => Promise<void>;
 }
 
-interface BootstrapConfig {
-  config?: BosConfig;
-  secrets?: Record<string, string>;
-  host?: { url?: string };
-  ui?: { source?: SourceMode };
-  api?: { source?: SourceMode; proxy?: string };
-  database?: { url?: string };
+interface ServerInput {
+  config: RuntimeConfig;
 }
 
 const patchConsole = (
@@ -300,7 +336,7 @@ const patchConsole = (
 export const spawnRemoteHost = (
   config: DevProcess,
   callbacks: ProcessCallbacks,
-  bosConfig?: BosConfig
+  runtimeConfig: RuntimeConfig
 ) =>
   Effect.gen(function* () {
     const remoteUrl = config.env?.HOST_REMOTE_URL;
@@ -317,27 +353,6 @@ export const spawnRemoteHost = (
 
     callbacks.onStatus(config.name, "starting");
 
-    let hostUrl = `http://localhost:${config.port}`;
-    if (process.env.HOST_URL) {
-      hostUrl = process.env.HOST_URL;
-    }
-
-    const hostSecrets = loadSecretsFor("host");
-    const apiSecrets = loadSecretsFor("api");
-    const allSecrets = { ...hostSecrets, ...apiSecrets };
-
-    const uiSource = (config.env?.UI_SOURCE as SourceMode) ?? "local";
-    const apiSource = (config.env?.API_SOURCE as SourceMode) ?? "local";
-    const apiProxy = config.env?.API_PROXY;
-
-    const bootstrap: BootstrapConfig = {
-      config: bosConfig,
-      secrets: allSecrets,
-      host: { url: hostUrl },
-      ui: { source: uiSource },
-      api: { source: apiSource, proxy: apiProxy },
-    };
-
     callbacks.onLog(config.name, `Remote: ${remoteUrl}`);
 
     const restoreConsole = patchConsole(config.name, callbacks);
@@ -369,7 +384,7 @@ export const spawnRemoteHost = (
     callbacks.onLog(config.name, `Loading host from ${remoteEntryUrl}...`);
 
     const hostModule = yield* Effect.tryPromise({
-      try: () => mf.loadRemote<{ runServer: (bootstrap?: BootstrapConfig) => ServerHandle }>("host/Server"),
+      try: () => mf.loadRemote<{ runServer: (input: ServerInput) => ServerHandle }>("host/Server"),
       catch: (e) => new Error(`Failed to load host module: ${e}`),
     });
 
@@ -378,7 +393,7 @@ export const spawnRemoteHost = (
     }
 
     callbacks.onLog(config.name, "Starting server...");
-    const serverHandle = hostModule.runServer(bootstrap);
+    const serverHandle = hostModule.runServer({ config: runtimeConfig });
 
     yield* Effect.tryPromise({
       try: () => serverHandle.ready,
@@ -415,8 +430,29 @@ export const makeDevProcess = (
       return yield* Effect.fail(new Error(`Unknown package: ${pkg}`));
     }
 
-    if (pkg === "host" && env?.HOST_SOURCE === "remote") {
-      return yield* spawnRemoteHost(config, callbacks, bosConfig);
+    if (pkg === "host" && bosConfig) {
+      const uiSource = (env?.UI_SOURCE as SourceMode) ?? "local";
+      const apiSource = (env?.API_SOURCE as SourceMode) ?? "local";
+      const apiProxy = env?.API_PROXY;
+
+      let hostUrl = `http://localhost:${config.port}`;
+      if (process.env.HOST_URL) {
+        hostUrl = process.env.HOST_URL;
+      }
+
+      const runtimeConfig = buildRuntimeConfig(bosConfig, {
+        uiSource,
+        apiSource,
+        hostUrl,
+        proxy: apiProxy,
+        env: "development",
+      });
+
+      if (env?.HOST_SOURCE === "remote") {
+        return yield* spawnRemoteHost(config, callbacks, runtimeConfig);
+      }
+
+      return yield* spawnDevProcess(config, callbacks, runtimeConfig);
     }
 
     return yield* spawnDevProcess(config, callbacks);

package/src/lib/resource-monitor/diff.ts

@@ -21,17 +21,13 @@ export const diffSnapshots = (from: Snapshot, to: Snapshot): SnapshotDiff => {
     }
   }
 
-  const stillBoundPids = new Set(
-    stillBoundPorts.map((p) => p.pid).filter((pid): pid is number => pid !== null)
-  );
-
-  const orphanedProcesses = from.processes.filter(
-    (p) =>
-      fromPids.has(p.pid) &&
-      !toPids.has(p.pid) &&
-      isProcessAliveSync(p.pid) &&
-      stillBoundPids.has(p.pid)
-  );
+  const orphanedProcesses = from.processes.filter((p) => {
+    const wasInBaseline = fromPids.has(p.pid);
+    const notInAfter = !toPids.has(p.pid);
+    const stillAlive = isProcessAliveSync(p.pid);
+    
+    return wasInBaseline && notInAfter && stillAlive;
+  });
 
   const newProcesses = to.processes.filter((p) => !fromPids.has(p.pid));
   const killedProcesses = from.processes.filter((p) => !toPids.has(p.pid));

package/src/lib/resource-monitor/platform/darwin.ts

@@ -211,7 +211,7 @@ const getMemoryInfo = (): Effect.Effect<MemoryInfo, never> =>
     return {
       total,
       used,
-      free: total - used,
+      free: Math.max(0, total - used),
       processRss: 0,
     };
   });

package/src/lib/sync.ts

@@ -1,133 +1 @@
-import { execa } from "execa";
-import { cp, mkdir, mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname, join } from "path";
-import type { BosConfig } from "../config";
-
-export interface FileSyncResult {
-  package: string;
-  files: string[];
-  depsAdded?: string[];
-  depsUpdated?: string[];
-}
-
-export interface FileSyncOptions {
-  configDir: string;
-  packages: string[];
-  bosConfig: BosConfig;
-  catalog?: Record<string, string>;
-  force?: boolean;
-}
-
-export async function syncFiles(options: FileSyncOptions): Promise<FileSyncResult[]> {
-  const { configDir, packages, bosConfig, catalog = {}, force } = options;
-  const results: FileSyncResult[] = [];
-
-  for (const pkg of packages) {
-    const pkgDir = `${configDir}/${pkg}`;
-    const pkgDirExists = await Bun.file(`${pkgDir}/package.json`).exists();
-    if (!pkgDirExists) continue;
-
-    const appConfig = bosConfig.app[pkg] as {
-      template?: string;
-      files?: string[];
-      sync?: { dependencies?: boolean; devDependencies?: boolean };
-    };
-
-    if (!appConfig?.template || !appConfig?.files) {
-      continue;
-    }
-
-    const tempDir = await mkdtemp(join(tmpdir(), `bos-files-${pkg}-`));
-
-    try {
-      await execa("npx", ["degit", appConfig.template, tempDir, "--force"], {
-        stdio: "pipe",
-      });
-
-      const filesSynced: string[] = [];
-      const depsAdded: string[] = [];
-      const depsUpdated: string[] = [];
-
-      for (const file of appConfig.files) {
-        const srcPath = join(tempDir, file);
-        const destPath = join(pkgDir, file);
-
-        try {
-          const destDir = dirname(destPath);
-          await mkdir(destDir, { recursive: true });
-          await cp(srcPath, destPath, { force: true, recursive: true });
-          filesSynced.push(file);
-        } catch {
-        }
-      }
-
-      const syncConfig = appConfig.sync ?? { dependencies: true, devDependencies: true };
-
-      if (syncConfig.dependencies !== false || syncConfig.devDependencies !== false) {
-        const templatePkgPath = join(tempDir, "package.json");
-        const localPkgPath = join(pkgDir, "package.json");
-
-        try {
-          const templatePkg = await Bun.file(templatePkgPath).json() as {
-            dependencies?: Record<string, string>;
-            devDependencies?: Record<string, string>;
-            scripts?: Record<string, string>;
-          };
-          const localPkg = await Bun.file(localPkgPath).json() as {
-            dependencies?: Record<string, string>;
-            devDependencies?: Record<string, string>;
-            scripts?: Record<string, string>;
-          };
-
-          if (syncConfig.dependencies !== false && templatePkg.dependencies) {
-            if (!localPkg.dependencies) localPkg.dependencies = {};
-            for (const [name, version] of Object.entries(templatePkg.dependencies)) {
-              if (!(name in localPkg.dependencies)) {
-                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
-                depsAdded.push(name);
-              } else if (localPkg.dependencies[name] !== "catalog:" && version !== localPkg.dependencies[name]) {
-                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
-                depsUpdated.push(name);
-              }
-            }
-          }
-
-          if (syncConfig.devDependencies !== false && templatePkg.devDependencies) {
-            if (!localPkg.devDependencies) localPkg.devDependencies = {};
-            for (const [name, version] of Object.entries(templatePkg.devDependencies)) {
-              if (!(name in localPkg.devDependencies)) {
-                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
-                depsAdded.push(name);
-              } else if (localPkg.devDependencies[name] !== "catalog:" && version !== localPkg.devDependencies[name]) {
-                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
-                depsUpdated.push(name);
-              }
-            }
-          }
-
-          if (templatePkg.scripts) {
-            if (!localPkg.scripts) localPkg.scripts = {};
-            for (const [name, script] of Object.entries(templatePkg.scripts)) {
-              localPkg.scripts[name] = script;
-            }
-          }
-
-          await Bun.write(localPkgPath, JSON.stringify(localPkg, null, 2));
-        } catch {
-        }
-      }
-
-      results.push({
-        package: pkg,
-        files: filesSynced,
-        depsAdded: depsAdded.length > 0 ? depsAdded : undefined,
-        depsUpdated: depsUpdated.length > 0 ? depsUpdated : undefined,
-      });
-    } finally {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  }
-
-  return results;
-}
+export { syncFiles, type FileSyncOptions, type FileSyncResult } from "../ui/files";

package/src/plugin.ts

@@ -159,7 +159,33 @@ function determineProcesses(config: AppConfig): string[] {
   return processes;
 }
 
-function buildEnvVars(config: AppConfig): Record<string, string> {
+function isValidProxyUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function resolveProxyUrl(bosConfig: BosConfigType | null): string | null {
+  if (!bosConfig) return null;
+  
+  const apiConfig = bosConfig.app.api as RemoteConfig | undefined;
+  if (!apiConfig) return null;
+
+  if (apiConfig.proxy && isValidProxyUrl(apiConfig.proxy)) {
+    return apiConfig.proxy;
+  }
+  
+  if (apiConfig.production && isValidProxyUrl(apiConfig.production)) {
+    return apiConfig.production;
+  }
+  
+  return null;
+}
+
+function buildEnvVars(config: AppConfig, bosConfig?: BosConfigType | null): Record<string, string> {
   const env: Record<string, string> = {};
 
   env.HOST_SOURCE = config.host;
@@ -174,9 +200,11 @@ function buildEnvVars(config: AppConfig): Record<string, string> {
   }
 
   if (config.proxy) {
-    const bosConfig = loadConfig();
-    const apiConfig = bosConfig?.app.api as RemoteConfig | undefined;
-    env.API_PROXY = apiConfig?.proxy || apiConfig?.production || "true";
+    const resolvedBosConfig = bosConfig ?? loadConfig();
+    const proxyUrl = resolveProxyUrl(resolvedBosConfig);
+    if (proxyUrl) {
+      env.API_PROXY = proxyUrl;
+    }
   }
 
   return env;
@@ -248,8 +276,28 @@ export default createPlugin({
         }
       }
 
+      let proxyUrl: string | undefined;
+      if (appConfig.proxy) {
+        proxyUrl = resolveProxyUrl(deps.bosConfig) ?? undefined;
+        if (!proxyUrl) {
+          console.log();
+          console.log(colors.red(`  ${icons.err} Proxy mode requested but no valid proxy URL found`));
+          console.log(colors.dim(`    Configure 'api.proxy' or 'api.production' in bos.config.json`));
+          console.log();
+          return {
+            status: "error" as const,
+            description: "No valid proxy URL configured in bos.config.json",
+            processes: [],
+            autoRemote,
+          };
+        }
+        console.log();
+        console.log(colors.cyan(`  ${icons.arrow} API Proxy: ${colors.bold(proxyUrl)}`));
+        console.log();
+      }
+
       const processes = determineProcesses(appConfig);
-      const env = buildEnvVars(appConfig);
+      const env = buildEnvVars(appConfig, deps.bosConfig);
       const description = buildDescription(appConfig);
 
       const orchestrator: AppOrchestrator = {
@@ -1302,7 +1350,7 @@ export default createPlugin({
       };
     }),
 
-    sync: builder.sync.handler(async ({ input }) => {
+    update: builder.update.handler(async ({ input }) => {
       const { configDir, bosConfig } = deps;
 
       const DEFAULT_ACCOUNT = "every.near";
@@ -1476,24 +1524,20 @@ export default createPlugin({
           }
         }
 
-        let filesSynced: Array<{ package: string; files: string[] }> | undefined;
-
-        if (input.files) {
-          const results = await syncFiles({
-            configDir,
-            packages: Object.keys(updatedBosConfig.app),
-            bosConfig: updatedBosConfig,
-            catalog: rootPkg.workspaces?.catalog ?? {},
-            force: input.force,
-          });
+        const results = await syncFiles({
+          configDir,
+          packages: Object.keys(updatedBosConfig.app),
+          bosConfig: updatedBosConfig,
+          catalog: rootPkg.workspaces?.catalog ?? {},
+          force: input.force,
+        });
 
-          if (results.length > 0) {
-            filesSynced = results.map(r => ({ package: r.package, files: r.files }));
-          }
-        }
+        const filesSynced = results.length > 0 
+          ? results.map(r => ({ package: r.package, files: r.files }))
+          : undefined;
 
         return {
-          status: "synced" as const,
+          status: "updated" as const,
           account,
           gateway,
           socialUrl,

package/src/types.ts

@@ -4,8 +4,6 @@ export const SourceModeSchema = z.enum(["local", "remote"]);
 export type SourceMode = z.infer<typeof SourceModeSchema>;
 
 export const HostConfigSchema = z.object({
-  title: z.string(),
-  description: z.string().optional(),
   development: z.string(),
   production: z.string(),
   secrets: z.array(z.string()).optional(),
@@ -21,7 +19,6 @@ export const RemoteConfigSchema = z.object({
   production: z.string(),
   ssr: z.string().optional(),
   proxy: z.string().optional(),
-  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(),
@@ -88,3 +85,51 @@ export const PortConfigSchema = z.object({
   api: z.number(),
 });
 export type PortConfig = z.infer<typeof PortConfigSchema>;
+
+export const SharedConfigSchema = z.object({
+  requiredVersion: z.string().optional(),
+  singleton: z.boolean().optional(),
+  eager: z.boolean().optional(),
+  strictVersion: z.boolean().optional(),
+  shareScope: z.string().optional(),
+});
+export type SharedConfig = z.infer<typeof SharedConfigSchema>;
+
+export const RuntimeConfigSchema = z.object({
+  env: z.enum(["development", "production"]),
+  account: z.string(),
+  title: z.string().optional(),
+  hostUrl: z.string(),
+  shared: z.object({
+    ui: z.record(z.string(), SharedConfigSchema).optional(),
+  }).optional(),
+  ui: z.object({
+    name: z.string(),
+    url: z.string(),
+    ssrUrl: z.string().optional(),
+    source: SourceModeSchema,
+  }),
+  api: z.object({
+    name: z.string(),
+    url: z.string(),
+    source: SourceModeSchema,
+    proxy: z.string().optional(),
+    variables: z.record(z.string(), z.string()).optional(),
+    secrets: z.array(z.string()).optional(),
+  }),
+});
+export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
+
+export const ClientRuntimeConfigSchema = z.object({
+  env: z.enum(["development", "production"]),
+  account: z.string(),
+  hostUrl: z.string().optional(),
+  assetsUrl: z.string(),
+  apiBase: z.string(),
+  rpcBase: z.string(),
+  ui: z.object({
+    name: z.string(),
+    url: z.string(),
+  }).optional(),
+});
+export type ClientRuntimeConfig = z.infer<typeof ClientRuntimeConfigSchema>;

package/src/ui/files.ts

@@ -0,0 +1,134 @@
+import { execa } from "execa";
+import { cp, mkdir, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+
+export interface FileSyncResult {
+  package: string;
+  files: string[];
+  depsAdded?: string[];
+  depsUpdated?: string[];
+}
+
+export interface FileSyncOptions {
+  configDir: string;
+  packages: string[];
+  bosConfig: {
+    app: Record<string, {
+      template?: string;
+      files?: string[];
+      sync?: { dependencies?: boolean; devDependencies?: boolean };
+    }>;
+  };
+  catalog?: Record<string, string>;
+  force?: boolean;
+}
+
+export async function syncFiles(options: FileSyncOptions): Promise<FileSyncResult[]> {
+  const { configDir, packages, bosConfig, catalog = {}, force } = options;
+  const results: FileSyncResult[] = [];
+
+  for (const pkg of packages) {
+    const pkgDir = `${configDir}/${pkg}`;
+    const pkgDirExists = await Bun.file(`${pkgDir}/package.json`).exists();
+    if (!pkgDirExists) continue;
+
+    const appConfig = bosConfig.app[pkg];
+
+    if (!appConfig?.template || !appConfig?.files) {
+      continue;
+    }
+
+    const tempDir = await mkdtemp(join(tmpdir(), `bos-files-${pkg}-`));
+
+    try {
+      await execa("npx", ["degit", appConfig.template, tempDir, "--force"], {
+        stdio: "pipe",
+      });
+
+      const filesSynced: string[] = [];
+      const depsAdded: string[] = [];
+      const depsUpdated: string[] = [];
+
+      for (const file of appConfig.files) {
+        const srcPath = join(tempDir, file);
+        const destPath = join(pkgDir, file);
+
+        try {
+          const destDir = dirname(destPath);
+          await mkdir(destDir, { recursive: true });
+          await cp(srcPath, destPath, { force: true, recursive: true });
+          filesSynced.push(file);
+        } catch {
+        }
+      }
+
+      const syncConfig = appConfig.sync ?? { dependencies: true, devDependencies: true };
+
+      if (syncConfig.dependencies !== false || syncConfig.devDependencies !== false) {
+        const templatePkgPath = join(tempDir, "package.json");
+        const localPkgPath = join(pkgDir, "package.json");
+
+        try {
+          const templatePkg = await Bun.file(templatePkgPath).json() as {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+            scripts?: Record<string, string>;
+          };
+          const localPkg = await Bun.file(localPkgPath).json() as {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+            scripts?: Record<string, string>;
+          };
+
+          if (syncConfig.dependencies !== false && templatePkg.dependencies) {
+            if (!localPkg.dependencies) localPkg.dependencies = {};
+            for (const [name, version] of Object.entries(templatePkg.dependencies)) {
+              if (!(name in localPkg.dependencies)) {
+                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
+                depsAdded.push(name);
+              } else if (localPkg.dependencies[name] !== "catalog:" && version !== localPkg.dependencies[name]) {
+                localPkg.dependencies[name] = name in catalog ? "catalog:" : version;
+                depsUpdated.push(name);
+              }
+            }
+          }
+
+          if (syncConfig.devDependencies !== false && templatePkg.devDependencies) {
+            if (!localPkg.devDependencies) localPkg.devDependencies = {};
+            for (const [name, version] of Object.entries(templatePkg.devDependencies)) {
+              if (!(name in localPkg.devDependencies)) {
+                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
+                depsAdded.push(name);
+              } else if (localPkg.devDependencies[name] !== "catalog:" && version !== localPkg.devDependencies[name]) {
+                localPkg.devDependencies[name] = name in catalog ? "catalog:" : version;
+                depsUpdated.push(name);
+              }
+            }
+          }
+
+          if (templatePkg.scripts) {
+            if (!localPkg.scripts) localPkg.scripts = {};
+            for (const [name, script] of Object.entries(templatePkg.scripts)) {
+              localPkg.scripts[name] = script;
+            }
+          }
+
+          await Bun.write(localPkgPath, JSON.stringify(localPkg, null, 2));
+        } catch {
+        }
+      }
+
+      results.push({
+        package: pkg,
+        files: filesSynced,
+        depsAdded: depsAdded.length > 0 ? depsAdded : undefined,
+        depsUpdated: depsUpdated.length > 0 ? depsUpdated : undefined,
+      });
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  return results;
+}