@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/services/permissions/probers/screentime.js

@@ -0,0 +1,67 @@
+/**
+ * Screen Time prober.
+ *
+ * Native APIs (macOS 12+):
+ *   - STScreenTimeConfigurationObserver
+ *   - AuthorizationCenter.shared.requestAuthorization(for: .individual)
+ *
+ * Screen Time is gated by the FamilyControls entitlement
+ * (`com.apple.developer.family-controls`) which Apple grants only to
+ * approved apps. The Milady dev build doesn't have it, so we report
+ * `restricted/entitlement_required`.
+ *
+ * The mobile-signals plugin already exposes a more elaborate Screen Time
+ * status object on iOS — see
+ * `eliza/packages/native-plugins/mobile-signals/ios/.../ScreenTimeSupport.swift`.
+ * On macOS we mirror its philosophy: detect the entitlement, refuse to
+ * attempt the framework call without it.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { buildState, IS_DARWIN, platformUnsupportedState } from "./_bridge.js";
+const ID = "screentime";
+function hasFamilyControlsEntitlement() {
+    try {
+        const macOsDir = path.dirname(path.resolve(process.execPath));
+        const contentsDir = path.resolve(macOsDir, "..");
+        const embedded = path.join(contentsDir, "embedded.provisionprofile");
+        if (!existsSync(embedded))
+            return false;
+        const buf = readFileSync(embedded);
+        return buf.includes(Buffer.from("com.apple.developer.family-controls"));
+    }
+    catch {
+        return false;
+    }
+}
+export const screentimeProber = {
+    id: ID,
+    async check() {
+        if (!IS_DARWIN)
+            return platformUnsupportedState(ID);
+        if (!hasFamilyControlsEntitlement()) {
+            return buildState(ID, "restricted", {
+                canRequest: false,
+                restrictedReason: "entitlement_required",
+            });
+        }
+        // TODO: query STScreenTimeConfigurationObserver via FFI when we
+        // ship the entitlement.
+        return buildState(ID, "not-determined", { canRequest: true });
+    },
+    async request({ reason: _reason }) {
+        if (!IS_DARWIN)
+            return platformUnsupportedState(ID);
+        if (!hasFamilyControlsEntitlement()) {
+            return buildState(ID, "restricted", {
+                canRequest: false,
+                restrictedReason: "entitlement_required",
+                lastRequested: Date.now(),
+            });
+        }
+        return buildState(ID, "not-determined", {
+            canRequest: true,
+            lastRequested: Date.now(),
+        });
+    },
+};

package/dist/packages/agent/src/services/permissions/probers/shell.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shell access prober.
+ *
+ * Shell execution is app-internal — there's no OS permission for spawning
+ * child processes. We honor an in-app toggle (managed by the existing
+ * `PermissionManager.setShellEnabled` in
+ * `packages/app-core/platforms/electrobun/src/native/permissions.ts`).
+ *
+ * For now, default to `granted` on all platforms. The registry can swap
+ * this with a richer prober that consults the runtime config flag.
+ *
+ * INTEGRATION TODO: when the registry-side wiring lands, expose a hook so
+ * this prober can read the user-toggled `shellEnabled` flag without
+ * importing the Electrobun module (which is a one-way dependency from
+ * agent → app-core that the registry agent should mediate).
+ */
+import type { Prober } from "../contracts.js";
+export declare const shellProber: Prober;
+//# sourceMappingURL=shell.d.ts.map

package/dist/packages/agent/src/services/permissions/probers/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../../../../../src/services/permissions/probers/shell.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAmB,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAK/D,eAAO,MAAM,WAAW,EAAE,MAczB,CAAC"}

package/dist/packages/agent/src/services/permissions/probers/shell.js

@@ -0,0 +1,31 @@
+/**
+ * Shell access prober.
+ *
+ * Shell execution is app-internal — there's no OS permission for spawning
+ * child processes. We honor an in-app toggle (managed by the existing
+ * `PermissionManager.setShellEnabled` in
+ * `packages/app-core/platforms/electrobun/src/native/permissions.ts`).
+ *
+ * For now, default to `granted` on all platforms. The registry can swap
+ * this with a richer prober that consults the runtime config flag.
+ *
+ * INTEGRATION TODO: when the registry-side wiring lands, expose a hook so
+ * this prober can read the user-toggled `shellEnabled` flag without
+ * importing the Electrobun module (which is a one-way dependency from
+ * agent → app-core that the registry agent should mediate).
+ */
+import { buildState } from "./_bridge.js";
+const ID = "shell";
+export const shellProber = {
+    id: ID,
+    async check() {
+        return buildState(ID, "granted", { canRequest: false });
+    },
+    async request({ reason: _reason }) {
+        // Nothing to request — shell is app-internal.
+        return buildState(ID, "granted", {
+            canRequest: false,
+            lastRequested: Date.now(),
+        });
+    },
+};

package/dist/packages/agent/src/services/permissions/probers/website-blocking.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Website blocking prober.
+ *
+ * App-internal feature — implemented via hosts-file edits / VPN DNS / NE
+ * content blocker depending on platform. There's no OS-level permission
+ * dialog for "may this app block websites" beyond the elevation prompt
+ * the website-blocker plugin issues at block time.
+ *
+ * For the registry's purposes we report `granted` so the plumbing exists,
+ * and let the website-blocker plugin handle the elevation flow at
+ * `startBlock` time. The richer status (requires elevation, hosts file
+ * writable, etc.) lives in `WebsiteBlockerPluginLike.getStatus()`.
+ */
+import type { Prober } from "../contracts.js";
+export declare const websiteBlockingProber: Prober;
+//# sourceMappingURL=website-blocking.d.ts.map

package/dist/packages/agent/src/services/permissions/probers/website-blocking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-blocking.d.ts","sourceRoot":"","sources":["../../../../../../../src/services/permissions/probers/website-blocking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAmB,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAK/D,eAAO,MAAM,qBAAqB,EAAE,MAanC,CAAC"}

package/dist/packages/agent/src/services/permissions/probers/website-blocking.js

@@ -0,0 +1,27 @@
+/**
+ * Website blocking prober.
+ *
+ * App-internal feature — implemented via hosts-file edits / VPN DNS / NE
+ * content blocker depending on platform. There's no OS-level permission
+ * dialog for "may this app block websites" beyond the elevation prompt
+ * the website-blocker plugin issues at block time.
+ *
+ * For the registry's purposes we report `granted` so the plumbing exists,
+ * and let the website-blocker plugin handle the elevation flow at
+ * `startBlock` time. The richer status (requires elevation, hosts file
+ * writable, etc.) lives in `WebsiteBlockerPluginLike.getStatus()`.
+ */
+import { buildState } from "./_bridge.js";
+const ID = "website-blocking";
+export const websiteBlockingProber = {
+    id: ID,
+    async check() {
+        return buildState(ID, "granted", { canRequest: false });
+    },
+    async request({ reason: _reason }) {
+        return buildState(ID, "granted", {
+            canRequest: false,
+            lastRequested: Date.now(),
+        });
+    },
+};

package/dist/packages/agent/src/services/permissions/register-probers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Register all native permission probers with the central permissions
+ * registry.
+ *
+ * The runtime should call this exactly once at boot, after the registry
+ * has been instantiated. The sibling agent that owns the registry should
+ * wire this in at the same place where the registry is constructed.
+ *
+ * INTEGRATION TODO (registry-wiring agent): the runtime entrypoint that
+ * constructs the registry should look roughly like:
+ *
+ *     import { PermissionsRegistry } from "./permissions-registry";
+ *     import { registerAllProbers } from "@elizaos/agent/services/permissions/register-probers";
+ *
+ *     const registry = new PermissionsRegistry();
+ *     registerAllProbers(registry);
+ *     runtime.registerService("permissions", registry);
+ *
+ * Likely call sites (in this repo):
+ *   - packages/agent/src/runtime/eliza.ts (top-level runtime bootstrap)
+ *   - packages/app-core/platforms/electrobun/src/index.ts (Electrobun
+ *     desktop bootstrap, where the existing PermissionManager is created)
+ *   - packages/agent/src/runtime/dev-server.ts (dev mode entry)
+ */
+import type { IPermissionsRegistry } from "./contracts.js";
+import { ALL_PROBERS } from "./probers/index.js";
+export declare function registerAllProbers(registry: IPermissionsRegistry): void;
+export { ALL_PROBERS };
+//# sourceMappingURL=register-probers.d.ts.map

package/dist/packages/agent/src/services/permissions/register-probers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-probers.d.ts","sourceRoot":"","sources":["../../../../../../src/services/permissions/register-probers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAIvE;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/packages/agent/src/services/permissions/register-probers.js

@@ -0,0 +1,31 @@
+/**
+ * Register all native permission probers with the central permissions
+ * registry.
+ *
+ * The runtime should call this exactly once at boot, after the registry
+ * has been instantiated. The sibling agent that owns the registry should
+ * wire this in at the same place where the registry is constructed.
+ *
+ * INTEGRATION TODO (registry-wiring agent): the runtime entrypoint that
+ * constructs the registry should look roughly like:
+ *
+ *     import { PermissionsRegistry } from "./permissions-registry";
+ *     import { registerAllProbers } from "@elizaos/agent/services/permissions/register-probers";
+ *
+ *     const registry = new PermissionsRegistry();
+ *     registerAllProbers(registry);
+ *     runtime.registerService("permissions", registry);
+ *
+ * Likely call sites (in this repo):
+ *   - packages/agent/src/runtime/eliza.ts (top-level runtime bootstrap)
+ *   - packages/app-core/platforms/electrobun/src/index.ts (Electrobun
+ *     desktop bootstrap, where the existing PermissionManager is created)
+ *   - packages/agent/src/runtime/dev-server.ts (dev mode entry)
+ */
+import { ALL_PROBERS } from "./probers/index.js";
+export function registerAllProbers(registry) {
+    for (const prober of ALL_PROBERS) {
+        registry.registerProber(prober);
+    }
+}
+export { ALL_PROBERS };

package/dist/packages/agent/src/services/permissions-registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Central registry for system-permission state. Holds an in-memory map of
+ * `PermissionState` keyed by `PermissionId`, hydrates from disk on boot,
+ * persists changes (debounced), and exposes a pub/sub channel for the UI.
+ *
+ * Probers are pluggable — each `PermissionId` is wired to a `Prober` that
+ * knows how to `check()` the OS state and `request()` user consent. The
+ * registry is the single source of truth; native bridges register probers,
+ * features call `recordBlock()` to surface why a permission is needed.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { IPermissionsRegistry, PermissionId, PermissionState, Prober } from "@elizaos/shared";
+export type { IPermissionsRegistry, Prober } from "@elizaos/shared";
+export declare const PERMISSIONS_REGISTRY_SERVICE = "eliza_permissions_registry";
+interface PersistenceAdapter {
+    read(): PermissionState[] | null;
+    write(states: PermissionState[]): void;
+}
+export interface PermissionRegistryOptions {
+    persistence?: PersistenceAdapter;
+    /**
+     * Override the debounce window for persistence writes. Tests pass `0` for
+     * synchronous writes.
+     */
+    persistDebounceMs?: number;
+}
+export declare class PermissionRegistry extends Service implements IPermissionsRegistry {
+    static serviceType: string;
+    static start(runtime: IAgentRuntime): Promise<PermissionRegistry>;
+    capabilityDescription: string;
+    private readonly states;
+    private readonly probers;
+    private readonly subscribers;
+    private persistTimer;
+    private readonly persistence;
+    private readonly persistDebounceMs;
+    constructor(runtime: IAgentRuntime, options?: PermissionRegistryOptions);
+    hydrate(): void;
+    registerProber(prober: Prober): void;
+    get(id: PermissionId): PermissionState;
+    check(id: PermissionId): Promise<PermissionState>;
+    request(id: PermissionId, opts: {
+        reason: string;
+        feature: {
+            app: string;
+            action: string;
+        };
+    }): Promise<PermissionState>;
+    recordBlock(id: PermissionId, feature: {
+        app: string;
+        action: string;
+    }): void;
+    list(): PermissionState[];
+    pending(): PermissionState[];
+    subscribe(cb: (state: PermissionState[]) => void): () => void;
+    stop(): Promise<void>;
+    private commit;
+    private notify;
+    private schedulePersist;
+    private flushPersist;
+}
+//# sourceMappingURL=permissions-registry.d.ts.map

package/dist/packages/agent/src/services/permissions-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions-registry.d.ts","sourceRoot":"","sources":["../../../../../src/services/permissions-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EAAE,KAAK,aAAa,EAAU,OAAO,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EACV,oBAAoB,EACpB,YAAY,EACZ,eAAe,EACf,MAAM,EACP,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,4BAA4B,+BAA+B,CAAC;AA8BzE,UAAU,kBAAkB;IAC1B,IAAI,IAAI,eAAe,EAAE,GAAG,IAAI,CAAC;IACjC,KAAK,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;CACxC;AA4BD,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,qBAAa,kBACX,SAAQ,OACR,YAAW,oBAAoB;IAE/B,MAAM,CAAC,WAAW,SAAgC;WAErC,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAUvE,qBAAqB,SACkD;IAEvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IACnE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiD;IAC7E,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAE/B,OAAO,EAAE,aAAa,EAAE,OAAO,GAAE,yBAA8B;IAQ3E,OAAO,IAAI,IAAI;IAQf,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIpC,GAAG,CAAC,EAAE,EAAE,YAAY,GAAG,eAAe;IAOhC,KAAK,CAAC,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IAUjD,OAAO,CACX,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,GACjE,OAAO,CAAC,eAAe,CAAC;IAmB3B,WAAW,CACT,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GACvC,IAAI;IAaP,IAAI,IAAI,eAAe,EAAE;IAIzB,OAAO,IAAI,eAAe,EAAE;IAS5B,SAAS,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,IAAI,GAAG,MAAM,IAAI;IAOvD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,MAAM;IAed,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,YAAY;CAUrB"}

package/dist/packages/agent/src/services/permissions-registry.js

@@ -0,0 +1,213 @@
+/**
+ * Central registry for system-permission state. Holds an in-memory map of
+ * `PermissionState` keyed by `PermissionId`, hydrates from disk on boot,
+ * persists changes (debounced), and exposes a pub/sub channel for the UI.
+ *
+ * Probers are pluggable — each `PermissionId` is wired to a `Prober` that
+ * knows how to `check()` the OS state and `request()` user consent. The
+ * registry is the single source of truth; native bridges register probers,
+ * features call `recordBlock()` to surface why a permission is needed.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+import { logger, Service } from "@elizaos/core";
+export const PERMISSIONS_REGISTRY_SERVICE = "eliza_permissions_registry";
+const PENDING_BLOCK_WINDOW_MS = 24 * 60 * 60 * 1000;
+const PERSIST_DEBOUNCE_MS = 500;
+function currentPlatform() {
+    const p = process.platform;
+    return p === "darwin" || p === "win32" || p === "linux" ? p : "linux";
+}
+function defaultStateFor(id) {
+    return {
+        id,
+        status: "not-determined",
+        canRequest: true,
+        lastChecked: Date.now(),
+        platform: currentPlatform(),
+    };
+}
+function resolveStateDir() {
+    const explicit = process.env.MILADY_STATE_DIR ?? process.env.ELIZA_STATE_DIR;
+    if (explicit && explicit.trim())
+        return explicit;
+    return path.join(os.homedir(), ".milady");
+}
+function resolvePersistencePath() {
+    return path.join(resolveStateDir(), "permissions.json");
+}
+class FilePersistenceAdapter {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    read() {
+        if (!fs.existsSync(this.filePath))
+            return null;
+        const raw = fs.readFileSync(this.filePath, "utf8");
+        if (!raw.trim())
+            return null;
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        return parsed.filter((entry) => !!entry &&
+            typeof entry === "object" &&
+            typeof entry.id === "string");
+    }
+    write(states) {
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = `${this.filePath}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(states, null, 2), "utf8");
+        fs.renameSync(tmp, this.filePath);
+    }
+}
+export class PermissionRegistry extends Service {
+    static serviceType = PERMISSIONS_REGISTRY_SERVICE;
+    static async start(runtime) {
+        const instance = new PermissionRegistry(runtime);
+        instance.hydrate();
+        const { registerAllProbers } = await import("./permissions/register-probers.js");
+        registerAllProbers(instance);
+        return instance;
+    }
+    capabilityDescription = "Central registry for system permission state, probers, and pub/sub";
+    states = new Map();
+    probers = new Map();
+    subscribers = new Set();
+    persistTimer = null;
+    persistence;
+    persistDebounceMs;
+    constructor(runtime, options = {}) {
+        super(runtime);
+        this.persistence =
+            options.persistence ??
+                new FilePersistenceAdapter(resolvePersistencePath());
+        this.persistDebounceMs = options.persistDebounceMs ?? PERSIST_DEBOUNCE_MS;
+    }
+    hydrate() {
+        const loaded = this.persistence.read();
+        if (!loaded)
+            return;
+        for (const state of loaded) {
+            this.states.set(state.id, state);
+        }
+    }
+    registerProber(prober) {
+        this.probers.set(prober.id, prober);
+    }
+    get(id) {
+        const existing = this.states.get(id);
+        if (existing)
+            return existing;
+        const fresh = defaultStateFor(id);
+        return fresh;
+    }
+    async check(id) {
+        const prober = this.probers.get(id);
+        if (!prober) {
+            throw new Error(`[PermissionRegistry] no prober registered for ${id}`);
+        }
+        const next = await prober.check();
+        this.commit(id, next);
+        return next;
+    }
+    async request(id, opts) {
+        const prober = this.probers.get(id);
+        if (!prober) {
+            throw new Error(`[PermissionRegistry] no prober registered for ${id}`);
+        }
+        const next = await prober.request({ reason: opts.reason });
+        const withRequest = {
+            ...next,
+            lastRequested: Date.now(),
+            lastBlockedFeature: {
+                app: opts.feature.app,
+                action: opts.feature.action,
+                at: Date.now(),
+            },
+        };
+        this.commit(id, withRequest);
+        return withRequest;
+    }
+    recordBlock(id, feature) {
+        const current = this.states.get(id) ?? defaultStateFor(id);
+        const next = {
+            ...current,
+            lastBlockedFeature: {
+                app: feature.app,
+                action: feature.action,
+                at: Date.now(),
+            },
+        };
+        this.commit(id, next);
+    }
+    list() {
+        return Array.from(this.states.values());
+    }
+    pending() {
+        const cutoff = Date.now() - PENDING_BLOCK_WINDOW_MS;
+        return this.list().filter((s) => {
+            if (s.status === "not-determined")
+                return true;
+            if (s.lastBlockedFeature && s.lastBlockedFeature.at >= cutoff)
+                return true;
+            return false;
+        });
+    }
+    subscribe(cb) {
+        this.subscribers.add(cb);
+        return () => {
+            this.subscribers.delete(cb);
+        };
+    }
+    async stop() {
+        if (this.persistTimer) {
+            clearTimeout(this.persistTimer);
+            this.persistTimer = null;
+            this.flushPersist();
+        }
+    }
+    commit(id, next) {
+        this.states.set(id, next);
+        this.notify();
+        this.schedulePersist();
+    }
+    notify() {
+        if (this.subscribers.size === 0)
+            return;
+        const snapshot = this.list();
+        for (const sub of this.subscribers) {
+            try {
+                sub(snapshot);
+            }
+            catch (err) {
+                logger.warn({ err: err instanceof Error ? err.message : String(err) }, "[PermissionRegistry] subscriber threw");
+            }
+        }
+    }
+    schedulePersist() {
+        if (this.persistDebounceMs <= 0) {
+            this.flushPersist();
+            return;
+        }
+        if (this.persistTimer)
+            clearTimeout(this.persistTimer);
+        this.persistTimer = setTimeout(() => {
+            this.persistTimer = null;
+            this.flushPersist();
+        }, this.persistDebounceMs);
+        if (typeof this.persistTimer.unref === "function") {
+            this.persistTimer.unref();
+        }
+    }
+    flushPersist() {
+        try {
+            this.persistence.write(this.list());
+        }
+        catch (err) {
+            logger.error({ err: err instanceof Error ? err.message : String(err) }, "[PermissionRegistry] failed to persist state");
+        }
+    }
+}

package/dist/packages/agent/src/services/plugin-compiler.d.ts

@@ -0,0 +1,51 @@
+import * as esbuild from "esbuild";
+import type { VirtualFilesystemService } from "./virtual-filesystem.ts";
+export type PluginCompilerFormat = "esm" | "cjs";
+export interface PluginCompilerOptions {
+    vfs: VirtualFilesystemService;
+    /**
+     * Project id is informational; the VFS instance already binds to a project,
+     * but callers commonly carry the id alongside and we record it for logging.
+     */
+    projectId?: string;
+    /** Virtual entry path inside the VFS, e.g. `src/plugin.ts`. */
+    entry: string;
+    /** Virtual output path inside the VFS. Defaults to `dist/<entry-stem>.js`. */
+    outFile?: string;
+    format?: PluginCompilerFormat;
+    target?: string;
+    /**
+     * Patterns excluded from bundling. Defaults to ["@elizaos/*"] so the
+     * compiled plugin resolves elizaOS peers from the host runtime rather than
+     * inlining them.
+     */
+    external?: string[];
+    /** When true (default), inline a sourcemap into the output. */
+    sourcemap?: boolean;
+    /** When true (default), bundle dependencies. */
+    bundle?: boolean;
+    /** When false, suppress esbuild's default minification. Default false. */
+    minify?: boolean;
+}
+export interface PluginCompilerResult {
+    outFile: string;
+    format: PluginCompilerFormat;
+    target: string;
+    warnings: esbuild.Message[];
+    durationMs: number;
+}
+/**
+ * Compiles TypeScript plugin source from a project's VFS into JS, also written
+ * to the same VFS. The output is a real on-disk file that can be loaded via
+ * dynamic `import(pathToFileURL(...))`.
+ *
+ * Path-traversal protection is delegated to the VFS: every path that enters
+ * this compiler goes through `vfs.readFile` / `vfs.writeFile` /
+ * `vfs.resolveDiskPath`, which reject any path that would escape the project
+ * root.
+ */
+export declare class PluginCompiler {
+    compile(options: PluginCompilerOptions): Promise<PluginCompilerResult>;
+}
+export declare function createPluginCompiler(): PluginCompiler;
+//# sourceMappingURL=plugin-compiler.d.ts.map

package/dist/packages/agent/src/services/plugin-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-compiler.d.ts","sourceRoot":"","sources":["../../../../../src/services/plugin-compiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,KAAK,CAAC;AAEjD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,wBAAwB,CAAC;IAC9B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gDAAgD;IAChD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACnB,OAAO,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAoE7E;AAED,wBAAgB,oBAAoB,IAAI,cAAc,CAErD"}

package/dist/packages/agent/src/services/plugin-compiler.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import * as esbuild from "esbuild";
+const DEFAULT_TARGET = "node20";
+const DEFAULT_EXTERNAL = ["@elizaos/*"];
+/**
+ * Compiles TypeScript plugin source from a project's VFS into JS, also written
+ * to the same VFS. The output is a real on-disk file that can be loaded via
+ * dynamic `import(pathToFileURL(...))`.
+ *
+ * Path-traversal protection is delegated to the VFS: every path that enters
+ * this compiler goes through `vfs.readFile` / `vfs.writeFile` /
+ * `vfs.resolveDiskPath`, which reject any path that would escape the project
+ * root.
+ */
+export class PluginCompiler {
+    async compile(options) {
+        const { vfs, entry, outFile, format = "esm", target = DEFAULT_TARGET, external = DEFAULT_EXTERNAL, sourcemap = true, bundle = true, minify = false, } = options;
+        if (typeof entry !== "string" || entry.trim() === "") {
+            throw new Error("PluginCompiler.compile: `entry` is required");
+        }
+        const resolvedOut = outFile ?? defaultOutFile(entry);
+        const entrySource = await vfs.readFile(entry);
+        const entryDiskPath = vfs.resolveDiskPath(entry);
+        const outDiskPath = vfs.resolveDiskPath(resolvedOut);
+        const loader = inferLoader(entry);
+        const start = Date.now();
+        const result = await esbuild.build({
+            stdin: {
+                contents: entrySource,
+                resolveDir: path.dirname(entryDiskPath),
+                sourcefile: path.basename(entryDiskPath),
+                loader,
+            },
+            bundle,
+            write: false,
+            format,
+            target,
+            platform: "node",
+            external: [...external],
+            sourcemap: sourcemap ? "inline" : false,
+            minify,
+            logLevel: "silent",
+        });
+        const durationMs = Date.now() - start;
+        if (!result.outputFiles || result.outputFiles.length === 0) {
+            throw new Error("PluginCompiler.compile: esbuild produced no output files");
+        }
+        const primary = result.outputFiles[0];
+        if (!primary) {
+            throw new Error("PluginCompiler.compile: esbuild produced no output");
+        }
+        await vfs.writeFile(resolvedOut, primary.contents);
+        void outDiskPath;
+        return {
+            outFile: vfs.resolveVirtualPath(resolvedOut),
+            format,
+            target,
+            warnings: result.warnings,
+            durationMs,
+        };
+    }
+}
+export function createPluginCompiler() {
+    return new PluginCompiler();
+}
+function inferLoader(entry) {
+    const ext = path.extname(entry).toLowerCase();
+    switch (ext) {
+        case ".ts":
+            return "ts";
+        case ".tsx":
+            return "tsx";
+        case ".jsx":
+            return "jsx";
+        case ".mjs":
+        case ".cjs":
+        case ".js":
+            return "js";
+        default:
+            return "ts";
+    }
+}
+function defaultOutFile(entry) {
+    const normalized = entry.replace(/\\/g, "/").replace(/^\/+/, "");
+    const stem = normalized
+        .split("/")
+        .pop()
+        .replace(/\.(tsx?|jsx?|mjs|cjs)$/i, "");
+    return `dist/${stem}.js`;
+}