forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/compiler/recipes/registry.ts

@@ -1,23 +1,23 @@
-import type { IntegrationRecipe } from "../types/integration.ts";
-import type { PackageRecipe } from "../types/integration.ts";
-import {
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { PackageRecipe } from "../types/integration.ts";
+import {
   AI_PROVIDER_RECIPES,
   AI_RECIPE,
   FORGE_RECIPE,
   POSTHOG_RECIPE,
-  REFERENCE_ALIASES,
-  SENTRY_RECIPE,
-  STRIPE_RECIPE,
-  ZOD_RECIPE,
-} from "./definitions.ts";
-
-export interface IntegrationRecipeRegistry {
-  resolveRecipe(alias: string): IntegrationRecipe | null;
-  resolveByPackageName(packageName: string): IntegrationRecipe | null;
-  supports(alias: string): boolean;
-  list(): IntegrationRecipe[];
-}
-
+  REFERENCE_ALIASES,
+  SENTRY_RECIPE,
+  STRIPE_RECIPE,
+  ZOD_RECIPE,
+} from "./definitions.ts";
+
+export interface IntegrationRecipeRegistry {
+  resolveRecipe(alias: string): IntegrationRecipe | null;
+  resolveByPackageName(packageName: string): IntegrationRecipe | null;
+  supports(alias: string): boolean;
+  list(): IntegrationRecipe[];
+}
+
 const REFERENCE_RECIPES: Record<string, IntegrationRecipe> = {
   stripe: STRIPE_RECIPE,
   posthog: POSTHOG_RECIPE,
@@ -26,77 +26,77 @@ const REFERENCE_RECIPES: Record<string, IntegrationRecipe> = {
   forge: FORGE_RECIPE,
   ai: AI_RECIPE,
 };
-
-const ALL_RECIPES: IntegrationRecipe[] = [
-  STRIPE_RECIPE,
-  POSTHOG_RECIPE,
-  SENTRY_RECIPE,
+
+const ALL_RECIPES: IntegrationRecipe[] = [
+  STRIPE_RECIPE,
+  POSTHOG_RECIPE,
+  SENTRY_RECIPE,
   ZOD_RECIPE,
   FORGE_RECIPE,
   AI_RECIPE,
-  ...AI_PROVIDER_RECIPES,
-];
-
-function indexByPackageName(
-  recipes: IntegrationRecipe[],
-): Map<string, IntegrationRecipe> {
-  const map = new Map<string, IntegrationRecipe>();
-  for (const recipe of recipes) {
-    for (const pkg of recipe.packages) {
-      map.set(pkg.packageName, recipe);
-    }
-  }
-  return map;
-}
-
-const PACKAGE_INDEX = indexByPackageName(ALL_RECIPES);
-
-export function resolveRecipe(alias: string): IntegrationRecipe | null {
-  const normalized = alias.trim().toLowerCase();
-  const direct = REFERENCE_RECIPES[normalized];
-  if (direct) return direct;
-
-  const provider = AI_PROVIDER_RECIPES.find(
-    (r) =>
-      r.alias.toLowerCase() === normalized ||
-      r.alias === alias ||
-      r.packages.some((pkg) => pkg.packageName.toLowerCase() === normalized),
-  );
-  if (provider) return provider;
-
-  return null;
-}
-
-export function resolveByPackageName(
-  packageName: string,
-): IntegrationRecipe | null {
-  return PACKAGE_INDEX.get(packageName) ?? null;
-}
-
-export function supports(alias: string): boolean {
-  return resolveRecipe(alias) !== null;
-}
-
-export function list(): IntegrationRecipe[] {
-  return [...ALL_RECIPES];
-}
-
-export function isReferenceAlias(alias: string): boolean {
-  return (REFERENCE_ALIASES as readonly string[]).includes(alias.trim().toLowerCase());
-}
-
-export function packageRecipeFor(
-  recipe: IntegrationRecipe,
-  packageName: string,
-): PackageRecipe | undefined {
-  return recipe.packages.find((p) => p.packageName === packageName);
-}
-
-export function createRecipeRegistry(): IntegrationRecipeRegistry {
-  return {
-    resolveRecipe,
-    resolveByPackageName,
-    supports,
-    list,
-  };
-}
+  ...AI_PROVIDER_RECIPES,
+];
+
+function indexByPackageName(
+  recipes: IntegrationRecipe[],
+): Map<string, IntegrationRecipe> {
+  const map = new Map<string, IntegrationRecipe>();
+  for (const recipe of recipes) {
+    for (const pkg of recipe.packages) {
+      map.set(pkg.packageName, recipe);
+    }
+  }
+  return map;
+}
+
+const PACKAGE_INDEX = indexByPackageName(ALL_RECIPES);
+
+export function resolveRecipe(alias: string): IntegrationRecipe | null {
+  const normalized = alias.trim().toLowerCase();
+  const direct = REFERENCE_RECIPES[normalized];
+  if (direct) return direct;
+
+  const provider = AI_PROVIDER_RECIPES.find(
+    (r) =>
+      r.alias.toLowerCase() === normalized ||
+      r.alias === alias ||
+      r.packages.some((pkg) => pkg.packageName.toLowerCase() === normalized),
+  );
+  if (provider) return provider;
+
+  return null;
+}
+
+export function resolveByPackageName(
+  packageName: string,
+): IntegrationRecipe | null {
+  return PACKAGE_INDEX.get(packageName) ?? null;
+}
+
+export function supports(alias: string): boolean {
+  return resolveRecipe(alias) !== null;
+}
+
+export function list(): IntegrationRecipe[] {
+  return [...ALL_RECIPES];
+}
+
+export function isReferenceAlias(alias: string): boolean {
+  return (REFERENCE_ALIASES as readonly string[]).includes(alias.trim().toLowerCase());
+}
+
+export function packageRecipeFor(
+  recipe: IntegrationRecipe,
+  packageName: string,
+): PackageRecipe | undefined {
+  return recipe.packages.find((p) => p.packageName === packageName);
+}
+
+export function createRecipeRegistry(): IntegrationRecipeRegistry {
+  return {
+    resolveRecipe,
+    resolveByPackageName,
+    supports,
+    list,
+  };
+}

package/src/forge/compiler/sandbox/artifact-sanitize.ts

@@ -1,26 +1,26 @@
-import type { PackageApi } from "../types/package-graph.ts";
-import { canonicalJson } from "../primitives/serialize.ts";
-import { secretLeakScan } from "./secret-scan.ts";
-
-export function packageApiContainsSecretValues(
-  api: PackageApi,
-  knownSecretValues: Iterable<string> = [],
-): boolean {
-  const serialized = canonicalJson(api);
-  return secretLeakScan(serialized, {
-    knownSecretValues,
-    includeHighEntropy: false,
-  }).hasLeak;
-}
-
-/**
- * Ensures cached/emitted package analysis retains secret names only — never values.
- */
-export function assertPackageApiSecretSafe(
-  api: PackageApi,
-  knownSecretValues: Iterable<string> = [],
-): void {
-  if (packageApiContainsSecretValues(api, knownSecretValues)) {
-    throw new Error("package api artifact contains secret material");
-  }
-}
+import type { PackageApi } from "../types/package-graph.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import { secretLeakScan } from "./secret-scan.ts";
+
+export function packageApiContainsSecretValues(
+  api: PackageApi,
+  knownSecretValues: Iterable<string> = [],
+): boolean {
+  const serialized = canonicalJson(api);
+  return secretLeakScan(serialized, {
+    knownSecretValues,
+    includeHighEntropy: false,
+  }).hasLeak;
+}
+
+/**
+ * Ensures cached/emitted package analysis retains secret names only — never values.
+ */
+export function assertPackageApiSecretSafe(
+  api: PackageApi,
+  knownSecretValues: Iterable<string> = [],
+): void {
+  if (packageApiContainsSecretValues(api, knownSecretValues)) {
+    throw new Error("package api artifact contains secret material");
+  }
+}

package/src/forge/compiler/sandbox/backends/child.ts

@@ -1,123 +1,123 @@
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import type { SandboxLimits } from "../../types/cli.ts";
-import type { Dependency } from "../../types/package-graph.ts";
-import { SANDBOX_KILL_GRACE_MS } from "../limits.ts";
-
-export interface ChildRunResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number | null;
-  timedOut: boolean;
-  oomKilled: boolean;
-  startFailed: boolean;
-}
-
-export interface ChildRunner {
-  run(
-    dep: Dependency,
-    limits: SandboxLimits,
-    env: Record<string, string>,
-  ): Promise<ChildRunResult>;
-}
-
-const INSPECTOR_ENTRY = fileURLToPath(
-  new URL("../inspector-entry.ts", import.meta.url),
-);
-
-function resolveRuntimeExecutable(): string {
-  return process.execPath;
-}
-
-export const defaultChildRunner: ChildRunner = {
-  async run(dep, limits, env) {
-    const executable = resolveRuntimeExecutable();
-    const args = [INSPECTOR_ENTRY, dep.installPath];
-
-    return new Promise<ChildRunResult>((resolve) => {
-      let stdout = "";
-      let stderr = "";
-      let timedOut = false;
-      let oomKilled = false;
-      let startFailed = false;
-      let settled = false;
-
-      const child = spawn(executable, args, {
-        env: {
-          ...env,
-          FORGE_SANDBOX: "1",
-          NODE_OPTIONS: `--max-old-space-size=${limits.memoryMb}`,
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-      });
-
-      const killTimer = setTimeout(() => {
-        timedOut = true;
-        child.kill("SIGTERM");
-        setTimeout(() => {
-          if (!child.killed) {
-            child.kill("SIGKILL");
-          }
-        }, SANDBOX_KILL_GRACE_MS);
-      }, limits.timeoutMs);
-
-      child.stdout.on("data", (chunk: Buffer | string) => {
-        stdout += String(chunk);
-      });
-
-      child.stderr.on("data", (chunk: Buffer | string) => {
-        stderr += String(chunk);
-      });
-
-      child.on("error", () => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(killTimer);
-        startFailed = true;
-        resolve({
-          stdout,
-          stderr,
-          exitCode: null,
-          timedOut,
-          oomKilled,
-          startFailed,
-        });
-      });
-
-      child.on("close", (code, signal) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(killTimer);
-        if (signal === "SIGKILL" && timedOut) {
-          // timeout path
-        }
-        if (stderr.includes("heap out of memory") || stderr.includes("ENOMEM")) {
-          oomKilled = true;
-        }
-        resolve({
-          stdout,
-          stderr,
-          exitCode: code,
-          timedOut,
-          oomKilled,
-          startFailed,
-        });
-      });
-    });
-  },
-};
-
-let childRunner: ChildRunner = defaultChildRunner;
-
-export function setChildRunner(runner: ChildRunner | undefined): void {
-  childRunner = runner ?? defaultChildRunner;
-}
-
-export function getChildRunner(): ChildRunner {
-  return childRunner;
-}
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import type { SandboxLimits } from "../../types/cli.ts";
+import type { Dependency } from "../../types/package-graph.ts";
+import { SANDBOX_KILL_GRACE_MS } from "../limits.ts";
+
+export interface ChildRunResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  timedOut: boolean;
+  oomKilled: boolean;
+  startFailed: boolean;
+}
+
+export interface ChildRunner {
+  run(
+    dep: Dependency,
+    limits: SandboxLimits,
+    env: Record<string, string>,
+  ): Promise<ChildRunResult>;
+}
+
+const INSPECTOR_ENTRY = fileURLToPath(
+  new URL("../inspector-entry.ts", import.meta.url),
+);
+
+function resolveRuntimeExecutable(): string {
+  return process.execPath;
+}
+
+export const defaultChildRunner: ChildRunner = {
+  async run(dep, limits, env) {
+    const executable = resolveRuntimeExecutable();
+    const args = [INSPECTOR_ENTRY, dep.installPath];
+
+    return new Promise<ChildRunResult>((resolve) => {
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let oomKilled = false;
+      let startFailed = false;
+      let settled = false;
+
+      const child = spawn(executable, args, {
+        env: {
+          ...env,
+          FORGE_SANDBOX: "1",
+          NODE_OPTIONS: `--max-old-space-size=${limits.memoryMb}`,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      });
+
+      const killTimer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, SANDBOX_KILL_GRACE_MS);
+      }, limits.timeoutMs);
+
+      child.stdout.on("data", (chunk: Buffer | string) => {
+        stdout += String(chunk);
+      });
+
+      child.stderr.on("data", (chunk: Buffer | string) => {
+        stderr += String(chunk);
+      });
+
+      child.on("error", () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(killTimer);
+        startFailed = true;
+        resolve({
+          stdout,
+          stderr,
+          exitCode: null,
+          timedOut,
+          oomKilled,
+          startFailed,
+        });
+      });
+
+      child.on("close", (code, signal) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(killTimer);
+        if (signal === "SIGKILL" && timedOut) {
+          // timeout path
+        }
+        if (stderr.includes("heap out of memory") || stderr.includes("ENOMEM")) {
+          oomKilled = true;
+        }
+        resolve({
+          stdout,
+          stderr,
+          exitCode: code,
+          timedOut,
+          oomKilled,
+          startFailed,
+        });
+      });
+    });
+  },
+};
+
+let childRunner: ChildRunner = defaultChildRunner;
+
+export function setChildRunner(runner: ChildRunner | undefined): void {
+  childRunner = runner ?? defaultChildRunner;
+}
+
+export function getChildRunner(): ChildRunner {
+  return childRunner;
+}