@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/scripts/link-browser-server.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { execFileSync, execSync } from "node:child_process";
+/**
+ * Post-install setup for @elizaos/plugin-browser:
+ *
+ * 1. Builds the stagehand-server if dist/index.js is missing but source exists.
+ *
+ * 2. Symlinks the installed package's `dist/server` to the workspace's
+ *    stagehand-server source (the npm package doesn't ship the server).
+ *
+ * 3. Copies the workspace's patched process-manager.js over the npm
+ *    package's version (adds probe/reuse, port management, removes Docker
+ *    env defaults).
+ *
+ * Run automatically via the `postinstall` hook, or manually:
+ *   node scripts/link-browser-server.mjs
+ */
+import {
+  copyFileSync,
+  existsSync,
+  readlinkSync,
+  symlinkSync,
+  unlinkSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveRepoRootFromImportMeta } from "./lib/repo-root.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolveRepoRootFromImportMeta(import.meta.url);
+
+// ── Resolve plugin-browser package ───────────────────────────────────────────
+
+let pluginRoot;
+try {
+  const req = createRequire(join(repoRoot, "package.json"));
+  const pkgJson = req.resolve("@elizaos/plugin-browser/package.json");
+  pluginRoot = dirname(pkgJson);
+} catch {
+  console.log(
+    "[link-browser-server] @elizaos/plugin-browser not installed — skipping",
+  );
+  process.exit(0);
+}
+
+// ── 1. Build stagehand-server if needed ─────────────────────────────────────
+
+const stagehandDir = join(
+  repoRoot,
+  "plugins",
+  "plugin-browser",
+  "stagehand-server",
+);
+const stagehandIndex = join(stagehandDir, "dist", "index.js");
+const stagehandSrc = join(stagehandDir, "src", "index.ts");
+
+if (!existsSync(stagehandIndex) && existsSync(stagehandSrc)) {
+  console.log(
+    "[link-browser-server] Stagehand server not built — building now...",
+  );
+  try {
+    // Install deps if node_modules is missing, then compile TypeScript
+    if (!existsSync(join(stagehandDir, "node_modules"))) {
+      execSync("bun install --ignore-scripts", {
+        cwd: stagehandDir,
+        stdio: "inherit",
+      });
+    }
+    // Resolve tsc: prefer local node_modules/.bin, then bunx
+    const localTsc = join(stagehandDir, "node_modules", ".bin", "tsc");
+    if (existsSync(localTsc)) {
+      execFileSync(localTsc, [], { cwd: stagehandDir, stdio: "inherit" });
+    } else {
+      execFileSync("bunx", ["tsc"], {
+        cwd: stagehandDir,
+        stdio: "inherit",
+      });
+    }
+    console.log("[link-browser-server] Stagehand server built successfully");
+  } catch (err) {
+    console.error(
+      `[link-browser-server] Failed to build stagehand-server: ${err.message ?? err}`,
+    );
+  }
+}
+
+// ── 2. Symlink stagehand-server ──────────────────────────────────────────────
+
+if (existsSync(stagehandIndex)) {
+  const serverLink = join(pluginRoot, "dist", "server");
+
+  let needsLink = true;
+  if (existsSync(serverLink)) {
+    try {
+      const target = readlinkSync(serverLink);
+      if (target === stagehandDir) {
+        console.log("[link-browser-server] Symlink already up to date");
+        needsLink = false;
+      } else {
+        // Stale symlink — remove and recreate
+        unlinkSync(serverLink);
+      }
+    } catch {
+      // Not a symlink (real directory) — leave it alone
+      console.log(
+        "[link-browser-server] dist/server already exists as a directory — skipping symlink",
+      );
+      needsLink = false;
+    }
+  }
+
+  if (needsLink) {
+    try {
+      symlinkSync(stagehandDir, serverLink, "dir");
+      console.log(
+        `[link-browser-server] Linked: ${serverLink} -> ${stagehandDir}`,
+      );
+    } catch (err) {
+      console.error(`[link-browser-server] Failed to create symlink: ${err}`);
+    }
+  }
+} else {
+  console.log(
+    `[link-browser-server] Stagehand server not found at ${stagehandDir} — skipping symlink`,
+  );
+}
+
+// ── 3. Copy patched process-manager.js ───────────────────────────────────────
+// The workspace has a fixed process-manager that adds port probing/reuse,
+// removes Docker env defaults, and handles EADDRINUSE properly.
+
+const patchedPm = join(
+  repoRoot,
+  "plugins",
+  "plugin-browser",
+  "typescript",
+  "src",
+  "services",
+  "process-manager.patched.js",
+);
+const targetPm = join(pluginRoot, "dist", "services", "process-manager.js");
+
+if (existsSync(patchedPm) && existsSync(targetPm)) {
+  try {
+    copyFileSync(patchedPm, targetPm);
+    console.log("[link-browser-server] Copied patched process-manager.js");
+  } catch (err) {
+    console.error(
+      `[link-browser-server] Failed to copy process-manager.js: ${err}`,
+    );
+  }
+} else {
+  console.log(
+    "[link-browser-server] No patched process-manager.js found — skipping",
+  );
+}

package/scripts/link-docker-local-app-packages.mjs

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { resolveRepoRootFromImportMeta } from "./lib/repo-root.mjs";
+import { collectWorkspaceMaps } from "./lib/workspace-discovery.mjs";
+
+const repoRoot = resolveRepoRootFromImportMeta(import.meta.url);
+const rootPkg = JSON.parse(
+  fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"),
+);
+const { workspaceDirs } = collectWorkspaceMaps(
+  repoRoot,
+  rootPkg.workspaces ?? [],
+);
+const localPackages = [
+  "eliza/plugins/app-companion",
+  "eliza/plugins/app-elizamaker",
+  "eliza/plugins/app-documents",
+  "eliza/plugins/app-lifeops",
+  "eliza/plugins/app-steward",
+  "eliza/plugins/app-task-coordinator",
+  "eliza/plugins/app-training",
+  "eliza/plugins/app-shopify",
+  "eliza/plugins/app-vincent",
+  "eliza/packages/app-core",
+  "eliza/cloud/packages/sdk",
+  "eliza/packages/cloud-routing",
+  "eliza/packages/shared",
+  "eliza/packages/skills",
+  "eliza/packages/ui",
+  "eliza/packages/vault",
+  "eliza/plugins/plugin-agent-skills",
+  "eliza/plugins/plugin-browser",
+  "eliza/plugins/plugin-capacitor-bridge",
+  "eliza/plugins/plugin-coding-tools",
+  "eliza/plugins/plugin-computeruse",
+  "eliza/plugins/plugin-discord",
+  "eliza/plugins/plugin-elizacloud",
+  "eliza/plugins/plugin-imessage",
+  "eliza/plugins/plugin-local-embedding",
+  "eliza/plugins/plugin-local-inference",
+  "eliza/plugins/plugin-mcp",
+  "eliza/plugins/plugin-pdf",
+  "eliza/plugins/plugin-signal",
+  "eliza/plugins/plugin-streaming",
+  "eliza/packages/native-plugins/activity-tracker",
+  "eliza/plugins/plugin-sql",
+  "eliza/plugins/plugin-telegram",
+  "eliza/plugins/plugin-video",
+  "eliza/plugins/plugin-whatsapp",
+  "eliza/plugins/plugin-workflow",
+  "eliza/plugins/plugin-x402",
+];
+
+function resolveSourceExportPath(packageDir, exportPath) {
+  if (typeof exportPath !== "string" || !exportPath.startsWith("./dist/")) {
+    return exportPath;
+  }
+
+  if (pathExists(path.join(packageDir, exportPath))) {
+    return exportPath;
+  }
+
+  const sourcePath = exportPath
+    .replace("./dist/", "./src/")
+    .replace(/\.d\.ts$/, ".ts")
+    .replace(/\.js$/, ".ts");
+  if (pathExists(path.join(packageDir, sourcePath))) {
+    return sourcePath;
+  }
+
+  const rootEntrypointPath = exportPath
+    .replace("./dist/node/", "./")
+    .replace("./dist/browser/", "./")
+    .replace("./dist/", "./")
+    .replace(/\.d\.ts$/, ".ts")
+    .replace(/\.js$/, ".ts");
+  return pathExists(path.join(packageDir, rootEntrypointPath))
+    ? rootEntrypointPath
+    : exportPath;
+}
+
+function rewriteDistExportsToSource(packageDir, pkg) {
+  let changed = false;
+
+  function rewrite(value, key = "") {
+    if (key === "types") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const next = resolveSourceExportPath(packageDir, value);
+      changed ||= next !== value;
+      return next;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => rewrite(item));
+    }
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([entryKey, entry]) => [
+          entryKey,
+          rewrite(entry, entryKey),
+        ]),
+      );
+    }
+    return value;
+  }
+
+  const nextPkg = { ...pkg };
+  nextPkg.main = rewrite(pkg.main);
+  nextPkg.module = rewrite(pkg.module);
+  nextPkg.types = pkg.types;
+  nextPkg.exports = rewrite(pkg.exports);
+
+  return { changed, pkg: changed ? nextPkg : pkg };
+}
+
+const shimSkipEntries = new Set([
+  ".git",
+  ".turbo",
+  "node_modules",
+  "package.json",
+]);
+
+function linkPackageContents(packageDir, target) {
+  for (const entry of fs.readdirSync(packageDir, { withFileTypes: true })) {
+    if (shimSkipEntries.has(entry.name)) {
+      continue;
+    }
+    const sourcePath = path.join(packageDir, entry.name);
+    const targetPath = path.join(target, entry.name);
+    fs.symlinkSync(
+      path.relative(path.dirname(targetPath), sourcePath),
+      targetPath,
+    );
+  }
+}
+
+function linkPackageTarget({ packageDir, pkg, rewroteExports, target }) {
+  removePath(target);
+  if (!rewroteExports) {
+    fs.symlinkSync(
+      path.relative(path.dirname(target), packageDir),
+      target,
+      "dir",
+    );
+    return;
+  }
+
+  fs.mkdirSync(target, { recursive: true });
+  fs.writeFileSync(
+    path.join(target, "package.json"),
+    `${JSON.stringify(pkg, null, 2)}\n`,
+  );
+  linkPackageContents(packageDir, target);
+}
+
+function pathExists(filePath) {
+  try {
+    fs.lstatSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removePath(filePath) {
+  try {
+    const stat = fs.lstatSync(filePath);
+    if (stat.isSymbolicLink()) {
+      fs.unlinkSync(filePath);
+      return;
+    }
+    fs.rmSync(filePath, { force: true, recursive: stat.isDirectory() });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+
+function resolveRootPackageDir(packageName) {
+  const packageDir = path.join(
+    repoRoot,
+    "node_modules",
+    ...packageName.split("/"),
+  );
+  if (fs.existsSync(path.join(packageDir, "package.json"))) {
+    return packageDir;
+  }
+
+  const bunStoreDir = path.join(repoRoot, "node_modules", ".bun");
+  if (pathExists(bunStoreDir)) {
+    const packageSegments = packageName.split("/");
+    for (const entry of fs.readdirSync(bunStoreDir).sort().reverse()) {
+      const candidate = path.join(
+        bunStoreDir,
+        entry,
+        "node_modules",
+        ...packageSegments,
+      );
+      if (fs.existsSync(path.join(candidate, "package.json"))) {
+        return candidate;
+      }
+    }
+  }
+
+  throw new Error(
+    `Missing root package manifest: node_modules/${packageName}/package.json`,
+  );
+}
+
+function linkRootDependency({ packageName, target }) {
+  const packageDir = resolveRootPackageDir(packageName);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  removePath(target);
+  fs.symlinkSync(
+    path.relative(path.dirname(target), packageDir),
+    target,
+    "dir",
+  );
+}
+
+function resolveLocalPackageDir(packagePath) {
+  const candidates = [packagePath];
+  if (packagePath.startsWith("eliza/")) {
+    candidates.push(packagePath.slice("eliza/".length));
+  }
+
+  for (const candidate of candidates) {
+    const packageDir = path.join(repoRoot, candidate);
+    if (fs.existsSync(path.join(packageDir, "package.json"))) {
+      return packageDir;
+    }
+  }
+
+  throw new Error(
+    `Missing local package manifest: ${candidates
+      .map((candidate) =>
+        path.relative(repoRoot, path.join(repoRoot, candidate, "package.json")),
+      )
+      .join(" or ")}`,
+  );
+}
+
+function collectScopeDirs() {
+  const scopeDirs = new Set([path.join(repoRoot, "node_modules", "@elizaos")]);
+  for (const workspaceDir of workspaceDirs) {
+    const scopeDir = path.join(workspaceDir, "node_modules", "@elizaos");
+    if (pathExists(scopeDir)) {
+      scopeDirs.add(scopeDir);
+    }
+  }
+  return [...scopeDirs].sort();
+}
+
+let linked = 0;
+const scopeDirs = collectScopeDirs();
+for (const scopeDir of scopeDirs) {
+  fs.mkdirSync(scopeDir, { recursive: true });
+}
+
+for (const packagePath of localPackages) {
+  const packageDir = resolveLocalPackageDir(packagePath);
+  const packageJsonPath = path.join(packageDir, "package.json");
+
+  let pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  if (typeof pkg.name !== "string" || !pkg.name.startsWith("@elizaos/")) {
+    throw new Error(
+      `Invalid local package name in ${path.relative(repoRoot, packageJsonPath)}`,
+    );
+  }
+  const rewriteResult = rewriteDistExportsToSource(packageDir, pkg);
+  pkg = rewriteResult.pkg;
+
+  const packageName = pkg.name.slice("@elizaos/".length);
+  for (const scopeDir of scopeDirs) {
+    const target = path.join(scopeDir, packageName);
+    if (scopeDir !== path.join(repoRoot, "node_modules", "@elizaos")) {
+      if (!pathExists(target)) {
+        continue;
+      }
+    }
+    linkPackageTarget({
+      packageDir,
+      pkg,
+      rewroteExports: rewriteResult.changed,
+      target,
+    });
+    linked += 1;
+  }
+
+  if (pkg.name === "@elizaos/plugin-sql") {
+    const pluginSqlRootDeps = [
+      "@electric-sql/pglite",
+      "@neondatabase/serverless",
+      "dotenv",
+      "drizzle-orm",
+      "pg",
+      "uuid",
+      "ws",
+    ];
+    for (const rootDep of pluginSqlRootDeps) {
+      linkRootDependency({
+        packageName: rootDep,
+        target: path.join(packageDir, "node_modules", rootDep),
+      });
+      linkRootDependency({
+        packageName: rootDep,
+        target: path.join(packageDir, "typescript", "node_modules", rootDep),
+      });
+      // Also ensure root-level node_modules has it so ESM resolution always
+      // finds the package regardless of which symlink depth Node traverses.
+      try {
+        linkRootDependency({
+          packageName: rootDep,
+          target: path.join(repoRoot, "node_modules", rootDep),
+        });
+      } catch {
+        // Not all deps may be installed; non-fatal.
+      }
+    }
+  }
+
+  if (pkg.name === "@elizaos/app-core") {
+    for (const rootDep of ["@node-rs/argon2", "jose"]) {
+      linkRootDependency({
+        packageName: rootDep,
+        target: path.join(packageDir, "node_modules", rootDep),
+      });
+      // Also ensure root-level node_modules has it so ESM resolution always
+      // finds the package regardless of which symlink depth Node traverses.
+      linkRootDependency({
+        packageName: rootDep,
+        target: path.join(repoRoot, "node_modules", rootDep),
+      });
+    }
+  }
+}
+
+console.log(
+  `[docker-local-apps] linked ${linked} local package entr${linked === 1 ? "y" : "ies"}`,
+);

package/scripts/link-external-plugins.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/**
+ * Link standalone elizaOS plugin source checkouts into Eliza's
+ * node_modules tree as local workspace links — without adding them to
+ * any package.json as a dependency.
+ *
+ * Motivation: the user has the plugin-imessage source checked out at
+ * ~/src/plugin-imessage/typescript and wants to develop against it
+ * locally, but doesn't want to publish it to npm, doesn't want it
+ * pinned in package.json (which would break CI and fresh clones that
+ * don't have the sibling source), and doesn't want `bun install` to
+ * clobber the symlink. This script recreates the links on every
+ * postinstall pass so they survive dependency resolution.
+ *
+ * Extend EXTERNAL_PLUGIN_SOURCES to link additional standalone plugins.
+ * Entries whose source directory doesn't exist are silently skipped —
+ * this keeps the script safe for fresh clones or CI boxes that don't
+ * have the sibling checkout.
+ *
+ * This file intentionally reuses `createPackageLink` from
+ * setup-upstreams.mjs so the same symlink semantics (relative
+ * symlink on POSIX, junction on Windows, idempotent replace) apply.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  symlinkSync,
+  unlinkSync,
+} from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveRepoRootFromImportMeta } from "./lib/repo-root.mjs";
+import { createPackageLink } from "./setup-upstreams.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEFAULT_REPO_ROOT = resolveRepoRootFromImportMeta(import.meta.url);
+
+/**
+ * Standalone plugin source directories to link into node_modules. Each
+ * entry points at a directory containing a `package.json` whose `name`
+ * field starts with `@elizaos/` or `@elizaos/`. Paths may be absolute
+ * or relative to the repo root. Missing paths are skipped.
+ */
+export const EXTERNAL_PLUGIN_SOURCES = [
+  // plugin-imessage — two-way iMessage connector. Prefer the submodule
+  // at eliza/plugins/plugin-imessage; fall back to a sibling source checkout
+  // at ~/src/plugin-imessage for independent PR development.
+  path.resolve(
+    DEFAULT_REPO_ROOT,
+    "eliza",
+    "plugins",
+    "plugin-imessage",
+    "typescript",
+  ),
+  path.resolve(DEFAULT_REPO_ROOT, "..", "src", "plugin-imessage", "typescript"),
+];
+
+/**
+ * The three node_modules locations where Eliza expects `@elizaos/*`
+ * packages to resolve from — matches the list used by
+ * setup-upstreams.mjs so dynamic imports work from every entry
+ * point (root CLI, apps/app Vite shell, apps/home dashboard).
+ */
+function linkTargetsFor(repoRoot, scope, basename) {
+  return [
+    path.join(repoRoot, "node_modules", scope, basename),
+    path.join(repoRoot, "apps", "app", "node_modules", scope, basename),
+    path.join(repoRoot, "apps", "home", "node_modules", scope, basename),
+  ];
+}
+
+function readPackageName(pkgDir) {
+  const pkgPath = path.join(pkgDir, "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return typeof pkgJson.name === "string" ? pkgJson.name : null;
+  } catch {
+    return null;
+  }
+}
+
+function splitScoped(name) {
+  if (!name.startsWith("@")) return null;
+  const slash = name.indexOf("/");
+  if (slash === -1) return null;
+  return { scope: name.slice(0, slash), basename: name.slice(slash + 1) };
+}
+
+export function linkExternalPlugins(
+  repoRoot = DEFAULT_REPO_ROOT,
+  sources = EXTERNAL_PLUGIN_SOURCES,
+) {
+  let linked = 0;
+  let skipped = 0;
+
+  for (const sourceDir of sources) {
+    if (!existsSync(sourceDir)) {
+      skipped += 1;
+      continue;
+    }
+
+    const name = readPackageName(sourceDir);
+    if (!name) {
+      console.warn(
+        `[link-external-plugins] ${sourceDir} has no package.json name field — skipping`,
+      );
+      skipped += 1;
+      continue;
+    }
+
+    const parts = splitScoped(name);
+    if (!parts) {
+      console.warn(
+        `[link-external-plugins] ${name} is not a scoped package — skipping`,
+      );
+      skipped += 1;
+      continue;
+    }
+
+    for (const linkPath of linkTargetsFor(
+      repoRoot,
+      parts.scope,
+      parts.basename,
+    )) {
+      if (createPackageLink(linkPath, sourceDir)) {
+        linked += 1;
+      }
+    }
+
+    // Bun's ESM resolver traverses the **real** path of a symlinked
+    // package, not the symlink location, when walking up to find
+    // dependencies. Workspace-linked plugins live outside Eliza's
+    // tree, so `import "@elizaos/core"` from their dist/ walks up
+    // through ~/src/…/typescript/node_modules and finds nothing.
+    // `patch-deps.mjs` earlier removed the nested @elizaos/core from
+    // workspace-linked plugins to avoid version skew; we re-create it
+    // here as a symlink back to the repo root core. This way the
+    // plugin's resolver finds a single canonical core regardless of
+    // which path traversal strategy Bun uses.
+    const pluginCoreLink = path.join(
+      sourceDir,
+      "node_modules",
+      "@elizaos",
+      "core",
+    );
+    const rootCore = path.join(repoRoot, "node_modules", "@elizaos", "core");
+    if (existsSync(rootCore)) {
+      try {
+        mkdirSync(path.dirname(pluginCoreLink), { recursive: true });
+        // Replace whatever is there (dir, broken link, stale file).
+        try {
+          unlinkSync(pluginCoreLink);
+        } catch {
+          // ignore missing
+        }
+        symlinkSync(rootCore, pluginCoreLink, "dir");
+      } catch (err) {
+        console.warn(
+          `[link-external-plugins] failed to link @elizaos/core into ${sourceDir}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+  }
+
+  if (linked === 0 && skipped === 0) {
+    return { linked, skipped };
+  }
+
+  if (linked > 0) {
+    console.log(
+      `[link-external-plugins] Linked ${linked} external plugin ${linked === 1 ? "entry" : "entries"}`,
+    );
+  }
+
+  return { linked, skipped };
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename);
+
+if (isMain) {
+  try {
+    linkExternalPlugins();
+  } catch (error) {
+    console.error(
+      `[link-external-plugins] ${error instanceof Error ? error.message : String(error)}`,
+    );
+    process.exit(1);
+  }
+}