@holon-run/agentinbox 0.5.0 → 0.7.0

package/dist/src/sources/remote_modules.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteSourceModuleRegistry = void 0;
+exports.builtInModuleIdForSourceType = builtInModuleIdForSourceType;
+exports.moduleConfigForSource = moduleConfigForSource;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const github_1 = require("./github");
+const github_ci_1 = require("./github_ci");
+const feishu_1 = require("./feishu");
+const REMOTE_USER_MODULE_ROOT_DIR = "source-profiles";
+const BUILTIN_MODULE_IDS = new Set(["builtin.github_repo", "builtin.github_repo_ci", "builtin.feishu_bot"]);
+class RemoteSourceModuleRegistry {
+    moduleCache = new Map();
+    resolve(source, homeDir) {
+        if (source.sourceType === "github_repo") {
+            return Promise.resolve(GITHUB_REPO_MODULE);
+        }
+        if (source.sourceType === "github_repo_ci") {
+            return Promise.resolve(GITHUB_REPO_CI_MODULE);
+        }
+        if (source.sourceType === "feishu_bot") {
+            return Promise.resolve(FEISHU_BOT_MODULE);
+        }
+        if (source.sourceType !== "remote_source") {
+            throw new Error(`unsupported source type for remote module: ${source.sourceType}`);
+        }
+        return this.loadUserModule(source, homeDir);
+    }
+    async loadUserModule(source, homeDir) {
+        const config = source.config ?? {};
+        const profilePath = asNonEmptyString(config.profilePath);
+        if (!profilePath) {
+            throw new Error("remote_source requires config.profilePath (module path)");
+        }
+        const moduleRoot = node_path_1.default.resolve(homeDir, REMOTE_USER_MODULE_ROOT_DIR);
+        const resolvedPath = resolveAndValidateModulePath(moduleRoot, profilePath);
+        const cacheKey = `${resolvedPath}:${source.sourceKey}`;
+        const cached = this.moduleCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        if (!node_fs_1.default.existsSync(resolvedPath)) {
+            throw new Error(`remote_source module not found: ${resolvedPath}`);
+        }
+        const imported = await dynamicImportModule((0, node_url_1.pathToFileURL)(resolvedPath).href);
+        const module = (imported.default ?? imported);
+        if (!module || typeof module !== "object") {
+            throw new Error(`remote_source module must export default object: ${resolvedPath}`);
+        }
+        validateModuleContract(module, resolvedPath);
+        this.moduleCache.set(cacheKey, module);
+        return module;
+    }
+}
+exports.RemoteSourceModuleRegistry = RemoteSourceModuleRegistry;
+async function dynamicImportModule(moduleUrl) {
+    const importer = new Function("url", "return import(url);");
+    return importer(moduleUrl);
+}
+function builtInModuleIdForSourceType(sourceType) {
+    if (sourceType === "github_repo") {
+        return "builtin.github_repo";
+    }
+    if (sourceType === "github_repo_ci") {
+        return "builtin.github_repo_ci";
+    }
+    if (sourceType === "feishu_bot") {
+        return "builtin.feishu_bot";
+    }
+    return null;
+}
+function validateModuleContract(module, sourcePath) {
+    if (!module.id || typeof module.id !== "string") {
+        throw new Error(`remote_source module id must be a non-empty string: ${sourcePath}`);
+    }
+    if (BUILTIN_MODULE_IDS.has(module.id)) {
+        throw new Error(`remote_source module id is reserved: ${module.id}`);
+    }
+    if (typeof module.validateConfig !== "function") {
+        throw new Error(`remote_source module missing validateConfig(): ${sourcePath}`);
+    }
+    if (typeof module.buildManagedSourceSpec !== "function") {
+        throw new Error(`remote_source module missing buildManagedSourceSpec(): ${sourcePath}`);
+    }
+    if (typeof module.mapRawEvent !== "function") {
+        throw new Error(`remote_source module missing mapRawEvent(): ${sourcePath}`);
+    }
+    validateOptionalHook(module.describeCapabilities, "describeCapabilities", sourcePath);
+    validateOptionalHook(module.listSubscriptionShortcuts, "listSubscriptionShortcuts", sourcePath);
+    validateOptionalHook(module.expandSubscriptionShortcut, "expandSubscriptionShortcut", sourcePath);
+    validateOptionalHook(module.deriveTrackedResource, "deriveTrackedResource", sourcePath);
+    validateOptionalHook(module.projectLifecycleSignal, "projectLifecycleSignal", sourcePath);
+    validateOptionalHook(module.deriveInlinePreview, "deriveInlinePreview", sourcePath);
+}
+function validateOptionalHook(value, name, sourcePath) {
+    if (value !== undefined && typeof value !== "function") {
+        throw new Error(`remote_source module ${name} must be a function when provided: ${sourcePath}`);
+    }
+}
+function resolveAndValidateModulePath(moduleRoot, profilePath) {
+    const resolved = node_path_1.default.isAbsolute(profilePath)
+        ? node_path_1.default.resolve(profilePath)
+        : node_path_1.default.resolve(moduleRoot, profilePath);
+    const normalizedRoot = ensureTrailingSep(node_path_1.default.resolve(moduleRoot));
+    const normalizedResolved = node_path_1.default.resolve(resolved);
+    if (!normalizedResolved.startsWith(normalizedRoot) && normalizedResolved !== node_path_1.default.resolve(moduleRoot)) {
+        throw new Error(`remote_source profilePath must stay under ${moduleRoot}`);
+    }
+    return normalizedResolved;
+}
+function ensureTrailingSep(input) {
+    return input.endsWith(node_path_1.default.sep) ? input : `${input}${node_path_1.default.sep}`;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function asNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+const GITHUB_REPO_MODULE = {
+    id: "builtin.github_repo",
+    describeCapabilities(source) {
+        const config = (0, github_1.parseGithubSourceConfig)(source);
+        return {
+            sourceKind: "github_repo",
+            aliases: ["github_repo"],
+            configSchema: [
+                { name: "owner", type: "string", required: true, description: "GitHub repository owner." },
+                { name: "repo", type: "string", required: true, description: "GitHub repository name." },
+                { name: "uxcAuth", type: "string", required: false, description: "Optional uxc auth profile." },
+                { name: "eventTypes", type: "string[]", required: false, description: "Optional GitHub event type allowlist." },
+                { name: "perPage", type: "number", required: false, description: `Repository events requested per poll. Default ${config.perPage ?? 10}.` },
+                { name: "pollIntervalSecs", type: "number", required: false, description: `Polling interval in seconds. Default ${config.pollIntervalSecs ?? 30}.` },
+            ],
+            metadataFields: [
+                { name: "eventType", type: "string", description: "GitHub event type such as IssueCommentEvent." },
+                { name: "action", type: "string", description: "GitHub event action suffix such as created." },
+                { name: "author", type: "string|null", description: "Actor login for the event." },
+                { name: "isPullRequest", type: "boolean", description: "Whether the event targets a pull request surface." },
+                { name: "reviewState", type: "string|null", description: "Review decision state for PullRequestReviewEvent such as approved or changes_requested." },
+                { name: "labels", type: "string[]", description: "Labels extracted from the issue or pull request." },
+                { name: "mentions", type: "string[]", description: "Mention handles extracted from title/body/comment text." },
+                { name: "number", type: "number|null", description: "Issue or pull request number when present." },
+                { name: "repoFullName", type: "string", description: "Repository full name in owner/repo form." },
+                { name: "title", type: "string|null", description: "Issue, pull request, or comment title." },
+                { name: "body", type: "string|null", description: "Issue, pull request, or comment body text." },
+                { name: "url", type: "string|null", description: "Primary GitHub HTML URL for the event target." },
+            ],
+            payloadExamples: [
+                {
+                    id: "1234567891",
+                    type: "PullRequestReviewEvent",
+                    action: "created",
+                    actor: "Copilot",
+                    pull_request: { number: 67, title: "feat: add remote module capability hooks" },
+                    review: { state: "commented", body: "review summary" },
+                },
+                {
+                    id: "1234567892",
+                    type: "PullRequestEvent",
+                    action: "closed",
+                    actor: "jolestar",
+                    pull_request: { number: 72, title: "feat: add cleanup policy lifecycle engine", merged: true },
+                },
+            ],
+            eventVariantExamples: [
+                "IssueCommentEvent.created",
+                "PullRequestEvent.opened",
+                "PullRequestEvent.closed",
+                "PullRequestReviewEvent.created",
+                "PullRequestReviewCommentEvent.created",
+            ],
+        };
+    },
+    listSubscriptionShortcuts() {
+        return (0, github_1.githubSubscriptionShortcutSpec)();
+    },
+    expandSubscriptionShortcut(input) {
+        return (0, github_1.expandGithubSubscriptionShortcut)(input);
+    },
+    deriveTrackedResource(filter) {
+        return (0, github_1.deriveGithubTrackedResource)(filter);
+    },
+    projectLifecycleSignal(rawPayload) {
+        return (0, github_1.projectGithubLifecycleSignal)(rawPayload);
+    },
+    validateConfig(source) {
+        (0, github_1.parseGithubSourceConfig)(source);
+    },
+    buildManagedSourceSpec(source) {
+        const config = (0, github_1.parseGithubSourceConfig)(source);
+        return {
+            endpoint: github_1.GITHUB_ENDPOINT,
+            operation_id: "get:/repos/{owner}/{repo}/events",
+            args: {
+                owner: config.owner,
+                repo: config.repo,
+                per_page: config.perPage ?? 10,
+            },
+            mode: "poll",
+            poll_config: {
+                interval_secs: config.pollIntervalSecs ?? 30,
+                extract_items_pointer: "",
+                checkpoint_strategy: {
+                    type: "item_key",
+                    item_key_pointer: "/id",
+                    seen_window: 1024,
+                },
+            },
+            options: { auth: config.uxcAuth },
+        };
+    },
+    mapRawEvent(rawPayload, source) {
+        const config = (0, github_1.parseGithubSourceConfig)(source);
+        const normalized = (0, github_1.normalizeGithubRepoEvent)(source, config, rawPayload);
+        if (!normalized) {
+            return null;
+        }
+        return {
+            sourceNativeId: normalized.sourceNativeId,
+            eventVariant: normalized.eventVariant,
+            metadata: normalized.metadata ?? {},
+            rawPayload: normalized.rawPayload ?? rawPayload,
+            occurredAt: normalized.occurredAt,
+            deliveryHandle: normalized.deliveryHandle,
+        };
+    },
+};
+const GITHUB_REPO_CI_MODULE = {
+    id: "builtin.github_repo_ci",
+    describeCapabilities() {
+        return {
+            sourceKind: "github_repo_ci",
+            aliases: ["github_repo_ci"],
+            configSchema: [
+                { name: "owner", type: "string", required: true, description: "GitHub repository owner." },
+                { name: "repo", type: "string", required: true, description: "GitHub repository name." },
+                { name: "uxcAuth", type: "string", required: false, description: "Optional uxc auth profile." },
+                { name: "pollIntervalSecs", type: "number", required: false, description: "Polling interval in seconds." },
+                { name: "perPage", type: "number", required: false, description: "Workflow runs requested per poll." },
+                { name: "eventFilter", type: "string", required: false, description: "Optional GitHub workflow event filter." },
+                { name: "branch", type: "string", required: false, description: "Optional branch filter for workflow runs." },
+                { name: "statusFilter", type: "string", required: false, description: "Optional workflow status filter." },
+            ],
+            metadataFields: [
+                { name: "name", type: "string|null", description: "Workflow run name." },
+                { name: "status", type: "string", description: "Normalized workflow run status." },
+                { name: "conclusion", type: "string|null", description: "Workflow run conclusion when completed." },
+                { name: "event", type: "string|null", description: "GitHub trigger event for the workflow run." },
+                { name: "headBranch", type: "string|null", description: "Head branch for the workflow run." },
+                { name: "headSha", type: "string|null", description: "Head commit SHA for the workflow run." },
+                { name: "actor", type: "string|null", description: "Actor login for the workflow run." },
+                { name: "commitMessage", type: "string|null", description: "Head commit message when present." },
+                { name: "htmlUrl", type: "string|null", description: "GitHub Actions run URL." },
+            ],
+            eventVariantExamples: ["workflow_run.ci.completed.failure", "workflow_run.nightly_checks.observed"],
+        };
+    },
+    deriveInlinePreview(item) {
+        const repoFullName = asNonEmptyString(item.metadata.repoFullName);
+        const workflowName = asNonEmptyString(item.metadata.name)
+            ?? asNonEmptyString(item.metadata.displayTitle)
+            ?? asNonEmptyString(item.rawPayload.name)
+            ?? asNonEmptyString(item.rawPayload.display_title);
+        const headBranch = asNonEmptyString(item.metadata.headBranch) ?? asNonEmptyString(item.rawPayload.head_branch);
+        const conclusion = asNonEmptyString(item.metadata.conclusion) ?? asNonEmptyString(item.rawPayload.conclusion);
+        const status = asNonEmptyString(item.metadata.status) ?? asNonEmptyString(item.rawPayload.status);
+        const parts = [];
+        if (workflowName) {
+            parts.push(workflowName);
+        }
+        else {
+            parts.push("Workflow run");
+        }
+        if (conclusion) {
+            parts.push(`completed ${conclusion}`);
+        }
+        else if (status) {
+            parts.push(status);
+        }
+        if (repoFullName) {
+            parts.push(`for ${repoFullName}`);
+        }
+        if (headBranch) {
+            parts.push(`on ${headBranch}`);
+        }
+        return parts.join(" ");
+    },
+    validateConfig(source) {
+        (0, github_ci_1.parseGithubCiSourceConfig)(source);
+    },
+    buildManagedSourceSpec(source) {
+        const config = (0, github_ci_1.parseGithubCiSourceConfig)(source);
+        const args = {
+            owner: config.owner,
+            repo: config.repo,
+            per_page: config.perPage ?? github_ci_1.DEFAULT_GITHUB_CI_PER_PAGE,
+        };
+        if (config.eventFilter) {
+            args.event = config.eventFilter;
+        }
+        if (config.branch) {
+            args.branch = config.branch;
+        }
+        if (config.statusFilter) {
+            args.status = config.statusFilter;
+        }
+        return {
+            endpoint: github_ci_1.GITHUB_CI_ENDPOINT,
+            operation_id: "get:/repos/{owner}/{repo}/actions/runs",
+            args,
+            mode: "poll",
+            poll_config: {
+                interval_secs: config.pollIntervalSecs ?? github_ci_1.DEFAULT_GITHUB_CI_POLL_INTERVAL_SECS,
+                extract_items_pointer: "/workflow_runs",
+                checkpoint_strategy: {
+                    type: "content_hash",
+                    seen_window: 1024,
+                },
+            },
+            options: { auth: config.uxcAuth },
+        };
+    },
+    mapRawEvent(rawPayload, source) {
+        const config = (0, github_ci_1.parseGithubCiSourceConfig)(source);
+        const normalized = (0, github_ci_1.normalizeGithubWorkflowRunEvent)(source, config, rawPayload);
+        if (!normalized) {
+            return null;
+        }
+        return {
+            sourceNativeId: normalized.sourceNativeId,
+            eventVariant: normalized.eventVariant,
+            metadata: normalized.metadata ?? {},
+            rawPayload: normalized.rawPayload ?? rawPayload,
+            occurredAt: normalized.occurredAt,
+            deliveryHandle: normalized.deliveryHandle,
+        };
+    },
+};
+const FEISHU_BOT_MODULE = {
+    id: "builtin.feishu_bot",
+    describeCapabilities() {
+        return {
+            sourceKind: "feishu_bot",
+            aliases: ["feishu_bot"],
+            configSchema: [
+                { name: "appId", type: "string", required: true, description: "Feishu app ID." },
+                { name: "appSecret", type: "string", required: true, description: "Feishu app secret." },
+                { name: "eventTypes", type: "string[]", required: false, description: "Optional Feishu event type allowlist." },
+                { name: "chatIds", type: "string[]", required: false, description: "Optional Feishu chat allowlist." },
+                { name: "schemaUrl", type: "string", required: false, description: "Optional Feishu OpenAPI schema URL." },
+                { name: "replyInThread", type: "boolean", required: false, description: "Reply in thread when sending outbound messages." },
+                { name: "uxcAuth", type: "string", required: false, description: "Optional uxc auth profile." },
+            ],
+            metadataFields: [
+                { name: "eventType", type: "string", description: "Feishu event type." },
+                { name: "chatId", type: "string", description: "Target chat ID." },
+                { name: "chatType", type: "string|null", description: "Feishu chat type." },
+                { name: "messageId", type: "string", description: "Feishu message ID." },
+                { name: "messageType", type: "string", description: "Feishu message type such as text." },
+                { name: "senderOpenId", type: "string|null", description: "Sender open_id when present." },
+                { name: "senderType", type: "string|null", description: "Sender type." },
+                { name: "mentions", type: "string[]", description: "Mention names extracted from the message." },
+                { name: "mentionOpenIds", type: "string[]", description: "Mention open_ids extracted from the message." },
+                { name: "content", type: "string|null", description: "Normalized message content string." },
+                { name: "threadId", type: "string|null", description: "Thread or root message ID when present." },
+                { name: "parentId", type: "string|null", description: "Parent message ID when present." },
+            ],
+            eventVariantExamples: ["im.message.receive_v1.text"],
+        };
+    },
+    validateConfig(source) {
+        (0, feishu_1.parseFeishuSourceConfig)(source);
+    },
+    buildManagedSourceSpec(source) {
+        const config = (0, feishu_1.parseFeishuSourceConfig)(source);
+        return {
+            endpoint: config.endpoint ?? feishu_1.FEISHU_OPENAPI_ENDPOINT,
+            mode: "stream",
+            transport_hint: "feishu_long_connection",
+            options: { auth: config.uxcAuth },
+        };
+    },
+    mapRawEvent(rawPayload, source) {
+        const config = (0, feishu_1.parseFeishuSourceConfig)(source);
+        const normalized = (0, feishu_1.normalizeFeishuBotEvent)(source, config, rawPayload);
+        if (!normalized) {
+            return null;
+        }
+        return {
+            sourceNativeId: normalized.sourceNativeId,
+            eventVariant: normalized.eventVariant,
+            metadata: normalized.metadata ?? {},
+            rawPayload: normalized.rawPayload ?? rawPayload,
+            occurredAt: normalized.occurredAt,
+            deliveryHandle: normalized.deliveryHandle,
+        };
+    },
+};
+function moduleConfigForSource(source) {
+    const config = asRecord(source.config);
+    if (source.sourceType === "remote_source") {
+        return asRecord(config.profileConfig);
+    }
+    return config;
+}