target-supabase-sdk 0.1.9 → 0.2.0

package/src/node/task-node.ts

@@ -0,0 +1,284 @@
+import {
+    logManager,
+    withModule,
+    type LoggerWithScope,
+} from "../shared/log";
+import { scopeForNodeLoop } from "./node-log-scope";
+import { getErrorMessage, toError } from "../shared/utils/error.utils";
+import { TaskManager, type TaskRunResult } from "../task/task-manager";
+import { patchChangeTaskStatus, patchClaimTask } from "../task/task.api";
+import { TaskStatusAction } from "../task/task.interface";
+import { NodeLoopContext } from "./node.interface";
+import { BaseNodeRuntime } from "./node-runtime.base";
+
+/**
+ * Task worker node: commands → heartbeat → claim & execute tasks.
+ * Built on {@link BaseNodeRuntime}.
+ */
+class TaskNode extends BaseNodeRuntime {
+    private _availableTaskList: string[] = [];
+    private _includeRemote = true;
+
+    get availableTaskList(): readonly string[] {
+        return [...this._availableTaskList];
+    }
+
+    constructor() {
+        super("taskNode");
+    }
+
+    protected async onBeforeRegisterNode(logger: LoggerWithScope): Promise<void> {
+        logger.info("開始註冊任務", { topic: "node" });
+        const { availableTaskList, includeRemote } = await TaskManager.registerTasks({ logger });
+        this._availableTaskList = availableTaskList;
+        this._includeRemote = includeRemote;
+    }
+
+    protected async runLoopSteps(ctx: NodeLoopContext, heartbeatOk: boolean): Promise<void> {
+        const loopScope = scopeForNodeLoop({
+            module: `${this.runtimeModule}-loop-iteration`,
+            traceId: ctx.loopTraceId,
+            nodeId: ctx.nodeId,
+        });
+        if (!heartbeatOk) {
+            const { logger } = logManager.withScope(loopScope);
+            logger.warn("心跳失敗，本輪跳過任務認領", { topic: "node" });
+            return;
+        }
+        await this.runAsWorker(ctx);
+    }
+
+    async runAsWorker(ctx: NodeLoopContext) {
+        const { loopTraceId, nodeId } = ctx;
+        const loopScope = scopeForNodeLoop({ module: "runAsWorker", traceId: loopTraceId, nodeId });
+        const { logger } = logManager.withScope(loopScope);
+
+        const availableTaskList = this.availableTaskList;
+        if (availableTaskList.length === 0) {
+            logger.warn("未配置可認領任務類型，跳過本輪", { topic: "task" });
+            return;
+        }
+
+        logger.info("向 Supabase 認領任務", {
+            topic: "task",
+            data: { availableTaskList },
+        });
+        const { data: task, error: claimError } = await patchClaimTask({
+            nodeId,
+            availableTaskList: [...availableTaskList],
+            traceId: loopTraceId,
+        });
+        if (claimError) {
+            logger.error("認領任務 API 失敗", {
+                topic: "task",
+                data: {
+                    availableTaskList,
+                    error: claimError.message,
+                },
+            });
+            return;
+        }
+        if (task == null) {
+            logger.info("本輪無匹配的 TODO 任務", {
+                topic: "task",
+                data: { availableTaskList },
+            });
+            return;
+        }
+
+        logger.info("認領任務成功，準備執行", {
+            topic: "task",
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                taskStatus: task.details.status,
+            },
+        });
+
+        const taskTraceId = task.details.traceId ?? loopTraceId;
+        const taskScope = scopeForNodeLoop({
+            module: "prepareTask",
+            traceId: taskTraceId,
+            nodeId,
+            traceParentId: loopTraceId,
+        });
+        const { logger: prepareLogger } = logManager.withScope(taskScope);
+        const prepareResult = await TaskManager.prepareTask({
+            logger: prepareLogger,
+            task,
+            includeRemote: this._includeRemote,
+        });
+        const { isSuccess: isPrepareSuccess, taskFn, code, message, reason, step } = prepareResult;
+        if (!isPrepareSuccess || taskFn == null) {
+            prepareLogger.critical("任務準備失敗，無法繼續執行，中止任務並 RESET 為 OPEN", {
+                topic: "task",
+                data: {
+                    taskId: task.id,
+                    taskTypeKey: task.value,
+                    code,
+                    message,
+                    reason,
+                    step,
+                },
+            });
+            await this.abortTaskRun({
+                logger: prepareLogger,
+                taskId: task.id,
+                nodeId,
+                traceId: taskTraceId,
+            });
+            return;
+        }
+
+        const { logger: executeLogger } = logManager.withScope(withModule(taskScope, "executeTask"));
+        const onExecuteAbort = async (error?: Error) => {
+            logger.critical("任務執行遇到未知錯誤，中止任務並 RESET 為 OPEN", {
+                topic: "task",
+                data: {
+                    taskId: task.id,
+                    taskName: task.name,
+                    taskTypeKey: task.value,
+                    error: getErrorMessage(error),
+                },
+            });
+            await this.abortTaskRun({
+                logger: executeLogger,
+                taskId: task.id,
+                nodeId,
+                traceId: taskTraceId,
+            });
+        };
+
+        executeLogger.info("開始執行業務邏輯", {
+            topic: "task",
+            data: { taskId: task.id, displayName: taskFn.displayName },
+        });
+        const startTime = Date.now();
+        let result: TaskRunResult | null = null;
+        try {
+            result = await taskFn();
+        } catch (error) {
+            await onExecuteAbort(toError(error));
+            return;
+        }
+        if (result == null) {
+            await onExecuteAbort(new Error("任務執行結果為空"));
+            return;
+        }
+
+        executeLogger.info("任務執行完成", {
+            topic: "task",
+            data: { taskId: task.id, displayName: taskFn.displayName },
+        });
+        const { isSuccess: isTaskSuccess, cost, extra } = result ?? { isSuccess: false, cost: 0, extra: null };
+        if (isTaskSuccess) {
+            await this.finalizeTaskRun("success", {
+                logger: executeLogger,
+                taskId: task.id,
+                taskTypeKey: task.value,
+                nodeId,
+                cost,
+                extra,
+                traceId: taskTraceId,
+            });
+        } else {
+            await this.finalizeTaskRun("failure", {
+                logger: executeLogger,
+                taskId: task.id,
+                taskTypeKey: task.value,
+                nodeId,
+                cost,
+                extra,
+                traceId: taskTraceId,
+            });
+        }
+        const duration = Date.now() - startTime;
+        executeLogger.info("業務邏輯執行完成", {
+            topic: "task",
+            data: { taskId: task.id, durationMs: duration },
+        });
+    }
+
+    private async abortTaskRun(params: {
+        logger: LoggerWithScope;
+        taskId: string;
+        nodeId: string;
+        traceId: string;
+        extra?: TaskRunResult["extra"];
+    }): Promise<boolean> {
+        const { logger, taskId, nodeId, traceId, extra } = params;
+        const logData = { taskId, nodeId };
+        const extraValue = typeof extra === "string" ? extra : undefined;
+
+        const { error } = await patchChangeTaskStatus({
+            id: taskId,
+            action: TaskStatusAction.RESET,
+            nodeId,
+            extra: extraValue,
+            traceId,
+        });
+
+        if (error) {
+            logger.error(error.message, { topic: "task", data: logData });
+            return false;
+        }
+        logger.info("任務已中止並 RESET 為 OPEN", { topic: "task", data: logData });
+        return true;
+    }
+
+    private async finalizeTaskRun(
+        outcome: "success" | "failure",
+        params: {
+            logger: LoggerWithScope;
+            taskId: string;
+            taskTypeKey: string;
+            nodeId: string;
+            cost: TaskRunResult["cost"];
+            extra: TaskRunResult["extr\a"];
+            traceId: string;
+        }
+    ): Promise<void> {
+        const { logger, taskId, nodeId, taskTypeKey, cost, extra, traceId } = params;
+        const outcomePrefix = outcome === "success" ? "任務成功" : "任務失敗";
+        const logData = {
+            taskTypeKey,
+            taskId,
+            nodeId,
+            ...(extra != null && extra !== "" ? { extra } : {}),
+        };
+        const extraValue = typeof extra === "string" ? extra : undefined;
+
+        const { error: changeTaskStatusError } =
+            outcome === "success"
+                ? await patchChangeTaskStatus({
+                    id: taskId,
+                    action: TaskStatusAction.FINISH,
+                    nodeId,
+                    cost,
+                    extra: extraValue,
+                    traceId,
+                })
+                : await patchChangeTaskStatus({
+                    id: taskId,
+                    action: TaskStatusAction.RESET,
+                    nodeId,
+                    extra: extraValue,
+                    traceId,
+                });
+
+        if (changeTaskStatusError) {
+            const upperMessage = `${outcomePrefix}但是更新 TaskStatus 失敗，產生孤兒 Task，請儘快排查問題`;
+            logger.critical(upperMessage, { topic: "task", data: logData });
+            throw new Error(upperMessage);
+        }
+        logger.info("更新 TaskStatus 成功", { topic: "task", data: logData });
+        if (outcome === "success") {
+            logger.success("任務執行結束，業務邏輯成功", { topic: "task", data: logData });
+        } else {
+            logger.warn("任務執行結束，業務邏輯失敗", { topic: "task", data: logData });
+        }
+    }
+}
+
+export { TaskNode };

package/src/node/trigger-node.ts

@@ -0,0 +1,180 @@
+import { logManager, type LoggerWithScope } from "../shared/log";
+import { scopeForNodeLoop } from "./node-log-scope";
+import { postTask } from "../task/task-post.api";
+import { TaskStatus } from "../task/task.interface";
+import { patchTriggerFired, scanEnabledTriggers } from "../trigger/trigger.api";
+import type { Trigger, TriggerPostTaskAction } from "../trigger/trigger.interface";
+import { buildFireKey, isTriggerDue } from "../trigger/trigger.utils";
+import { NodeLoopContext } from "./node.interface";
+import { BaseNodeRuntime } from "./node-runtime.base";
+
+/**
+ * Dedicated trigger scheduler node.
+ * Main loop: commands → heartbeat → evaluate due triggers → postTask.
+ *
+ * Phase 1: run a **single** TriggerNode process per deployment to avoid duplicate fires.
+ */
+class TriggerNode extends BaseNodeRuntime {
+    constructor() {
+        super("triggerNode");
+    }
+
+    protected async onBeforeRegisterNode(logger: LoggerWithScope): Promise<void> {
+        logger.info("Trigger 節點啟動，跳過任務註冊", { topic: "trigger" });
+    }
+
+    protected async runLoopSteps(ctx: NodeLoopContext, heartbeatOk: boolean): Promise<void> {
+        const loopScope = scopeForNodeLoop({
+            module: `${this.runtimeModule}-loop-iteration`,
+            traceId: ctx.loopTraceId,
+            nodeId: ctx.nodeId,
+        });
+        if (!heartbeatOk) {
+            const { logger } = logManager.withScope(loopScope);
+            logger.warn("心跳失敗，本輪跳過 Trigger 評估", { topic: "trigger" });
+            return;
+        }
+        await this.evaluateTriggers(ctx);
+    }
+
+    async evaluateTriggers(ctx: NodeLoopContext): Promise<void> {
+        const { loopTraceId, nodeId } = ctx;
+        const loopScope = scopeForNodeLoop({ module: "evaluateTriggers", traceId: loopTraceId, nodeId });
+        const { logger } = logManager.withScope(loopScope);
+
+        logger.debug("開始評估 Trigger", { topic: "trigger" });
+
+        const { data: triggerList = [], error } = await scanEnabledTriggers({ traceId: loopTraceId });
+        if (error) {
+            logger.warn("掃描 Trigger 失敗", {
+                topic: "trigger",
+                data: { error: error.message },
+            });
+            return;
+        }
+        if (triggerList.length === 0) {
+            logger.info("無 ENABLED Trigger", { topic: "trigger" });
+            return;
+        }
+
+        const now = new Date();
+        let dueCount = 0;
+        let firedCount = 0;
+
+        for (const trigger of triggerList) {
+            if (!isTriggerDue(trigger, now)) {
+                continue;
+            }
+            dueCount++;
+            const fired = await this.fireTrigger(ctx, trigger, now);
+            if (fired) {
+                firedCount++;
+            }
+        }
+
+        logger.info("Trigger 評估完成", {
+            topic: "trigger",
+            data: {
+                scanned: triggerList.length,
+                due: dueCount,
+                fired: firedCount,
+            },
+        });
+    }
+
+    private async fireTrigger(ctx: NodeLoopContext, trigger: Trigger, now: Date): Promise<boolean> {
+        const { loopTraceId, nodeId } = ctx;
+        const { logger } = logManager.withScope(
+            scopeForNodeLoop({ module: "fireTrigger", traceId: loopTraceId, nodeId })
+        );
+
+        const fireKey = buildFireKey(trigger, now);
+        const action = trigger.details.action;
+
+        if (action.kind !== "post_task") {
+            logger.warn("不支援的 Trigger action", {
+                topic: "trigger",
+                data: { triggerId: trigger.id, kind: action.kind },
+            });
+            return false;
+        }
+
+        logger.info("Trigger 到期，準備 postTask", {
+            topic: "trigger",
+            data: {
+                triggerId: trigger.id,
+                triggerKey: trigger.value,
+                fireKey,
+                taskTypeKey: action.taskTypeKey,
+            },
+        });
+
+        const taskExtra = `trigger:${trigger.id}:${fireKey}`;
+        const { data: task, error: postError } = await postTask(
+            buildPostTaskPayload(trigger, action, taskExtra, loopTraceId)
+        );
+
+        if (postError) {
+            logger.error("Trigger postTask 失敗", {
+                topic: "trigger",
+                data: {
+                    triggerId: trigger.id,
+                    fireKey,
+                    error: postError.message,
+                },
+            });
+            return false;
+        }
+
+        const { error: patchError } = await patchTriggerFired({
+            triggerId: trigger.id,
+            fireKey,
+            expectedLastFireKey: trigger.details.lastFireKey ?? null,
+            traceId: loopTraceId,
+        });
+
+        if (patchError) {
+            logger.warn("Trigger 已 postTask 但更新 lastFireKey 失敗", {
+                topic: "trigger",
+                data: {
+                    triggerId: trigger.id,
+                    taskId: task?.id,
+                    fireKey,
+                    error: patchError.message,
+                },
+            });
+            return false;
+        }
+
+        logger.success("Trigger 觸發成功", {
+            topic: "trigger",
+            data: {
+                triggerId: trigger.id,
+                triggerKey: trigger.value,
+                fireKey,
+                taskId: task?.id,
+                taskTraceId: task?.details.traceId,
+            },
+        });
+        return true;
+    }
+}
+
+function buildPostTaskPayload(
+    trigger: Trigger,
+    action: TriggerPostTaskAction,
+    extra: string,
+    loopTraceId: string
+) {
+    return {
+        name: action.taskName ?? trigger.name,
+        value: action.taskTypeKey,
+        params: action.taskParams,
+        taskStatus: action.taskStatus ?? TaskStatus.TODO,
+        tagList: trigger.tagList ?? [],
+        extra,
+        traceParentId: loopTraceId,
+    };
+}
+
+export { TriggerNode };

package/src/node.ts

@@ -0,0 +1,62 @@
+/**
+ * Node.js runtime entry — browser API plus local FS / worker orchestration.
+ *
+ * import { TaskManager, RepoManager, TaskNode } from "target-supabase-sdk/node";
+ */
+
+export * from "./browser";
+
+export { TaskManager } from "./task/task-manager";
+export type {
+	PrepareTaskFailureReason,
+	PrepareTaskParams,
+	PrepareTaskResponse,
+	RegisterTasksOptions,
+	RegisterTasksResult,
+	TaskFn,
+	TaskRepoContext,
+	TaskRunResult,
+	ExecutableTaskFn,
+	TaskRepoScriptDetails,
+	TaskRepoScriptRecord,
+	TaskRunnerRootConfig,
+	TaskLocalPackageConfig,
+	BootstrapLocalTasksResult,
+	BootstrapLocalTasksStatus,
+} from "./task/task-manager";
+export {
+	TASK_REPO_SCRIPT_CATEGORY,
+	TASK_RUNNER_CONFIG_DIR,
+	TASK_RUNNER_ROOT_CONFIG_FILENAME,
+	TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH,
+	TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH,
+	TASK_LOCAL_PACKAGE_CONFIG_FILENAME,
+} from "./task/task-manager";
+
+export {
+	postTask,
+	postTaskSchema,
+} from "./task/task-post.api";
+export type { PostTaskPayload } from "./task/task-post.api";
+
+export {
+	TaskRepoValidation,
+	validateTaskRepoAndParams,
+} from "./task/task-repo-validation";
+export type {
+	TaskRepoValidationFailureReason,
+	ValidateTaskRepoAndParamsInput,
+	ValidateTaskRepoAndParamsResult,
+} from "./task/task-repo-validation";
+
+export { RepoManager } from "./repo/repo-manager";
+
+export { TaskNode } from "./node/task-node";
+export { TriggerNode } from "./node/trigger-node";
+export { BaseNodeRuntime } from "./node/node-runtime.base";
+
+export * from "./command/command.interface";
+export * from "./command/command.api";
+
+export * from "./trigger/trigger.interface";
+export * from "./trigger/trigger.api";

package/src/repo/repo-manager.ts

@@ -1,6 +1,6 @@
-import { getPossibleTarget } from "../core.api";
+import { getPossibleTarget } from "../core.api";
 import { SupabaseInitializer } from "../supabase";
-import { LoggerWithContext } from "../shared/log/log-manager";
+import { LoggerWithScope } from "../shared/log";
 import type { TaskRepoContext, TaskRepoScriptRecord } from "../task/task-repo-context";
 import { TASK_REPO_SCRIPT_CATEGORY } from "../task/task-repo-context";
 import {
@@ -24,16 +24,31 @@ type LocalRepoEntry =
 const localRepoRegistry = new Map<string, LocalRepoEntry>();
 const remoteContextCache = new Map<string, TaskRepoContext>();
 
+export type RepoContextFailureReason =
+    | "LOCAL_REPO_LOAD_FAILED"
+    | "LOCAL_REPO_NOT_FOUND"
+    | "REMOTE_REPO_NOT_FOUND"
+    | "REMOTE_REPO_LOAD_FAILED";
+
+export type RepoContextResolvedVia = "local" | "remote";
+
 export interface GetRepoContextParams {
-    logger: LoggerWithContext;
+    logger: LoggerWithScope;
     /** Task type key (`task.value`) — matches {@link Repo.value} for remote lookup; local registry key */
     taskTypeKey: string;
+    /**
+     * When false, skip Supabase fetch if the task type is not in the local registry.
+     * Default `true`.
+     */
+    includeRemote?: boolean;
 }
 
 export interface GetRepoContextResult<T extends TaskRepoContext = TaskRepoContext> {
     context: T | null;
     /** Present when `context` is null — import / DB / format failure at repo layer */
     error?: string;
+    failureReason?: RepoContextFailureReason;
+    resolvedVia?: RepoContextResolvedVia;
 }
 
 function buildRemoteCacheKey(taskTypeKey: string, contentHash: string): string {
@@ -65,7 +80,7 @@ async function fetchRemoteScripts(taskTypeKey: string): Promise<TaskRepoScriptRe
 }
 
 async function loadLocalEntry(
-    logger: LoggerWithContext,
+    logger: LoggerWithScope,
     entry: LocalRepoEntry,
     taskTypeKey: string
 ): Promise<TaskRepoContext | null> {
@@ -91,16 +106,16 @@ async function loadLocalEntry(
 }
 
 async function loadRemoteRepoContext(
-    logger: LoggerWithContext,
+    logger: LoggerWithScope,
     taskTypeKey: string
 ): Promise<GetRepoContextResult> {
-    logger.info("從 Supabase 加載 Repo", { topic: "repo", context: { taskTypeKey } });
+    logger.info("從 Supabase 加載 Repo", { topic: "repo", data: { taskTypeKey } });
 
     const remoteRepo = await fetchRemoteRepo(taskTypeKey);
     if (remoteRepo == null) {
         const error = `Supabase 未找到 Repo (value=${taskTypeKey})`;
-        logger.warn(error, { topic: "repo", context: { taskTypeKey } });
-        return { context: null, error };
+        logger.warn(error, { topic: "repo", data: { taskTypeKey } });
+        return { context: null, error, failureReason: "REMOTE_REPO_NOT_FOUND" };
     }
 
     const repoUrl = remoteRepo.details?.url?.trim() ?? "";
@@ -108,8 +123,8 @@ async function loadRemoteRepoContext(
     const cacheKey = buildRemoteCacheKey(taskTypeKey, repoHash);
     const cached = remoteContextCache.get(cacheKey);
     if (cached != null) {
-        logger.info("命中遠程 Repo 上下文緩存", { topic: "repo", context: { cacheKey } });
-        return { context: cached };
+        logger.info("命中遠程 Repo 上下文緩存", { topic: "repo", data: { cacheKey } });
+        return { context: cached, resolvedVia: "remote" };
     }
 
     const scripts = await fetchRemoteScripts(taskTypeKey);
@@ -123,7 +138,7 @@ async function loadRemoteRepoContext(
     if (loaded == null && repoUrl !== "") {
         logger.info("未找到 script 行，嘗試從 Repo.details.url 加載", {
             topic: "repo",
-            context: { taskTypeKey, url: repoUrl },
+            data: { taskTypeKey, url: repoUrl },
         });
         loaded = await loadRepoContextFromUrl({ logger, url: repoUrl, taskTypeKey });
     }
@@ -132,47 +147,55 @@ async function loadRemoteRepoContext(
         const error = `無法從 Repo 加載 TaskRepoContext (hasUrl=${repoUrl !== ""}, scriptCount=${scripts.length})`;
         logger.warn(error, {
             topic: "repo",
-            context: { taskTypeKey, hasUrl: repoUrl !== "", scriptCount: scripts.length },
+            data: { taskTypeKey, hasUrl: repoUrl !== "", scriptCount: scripts.length },
         });
-        return { context: null, error };
+        return { context: null, error, failureReason: "REMOTE_REPO_LOAD_FAILED" };
     }
 
     remoteContextCache.set(cacheKey, loaded.context);
-    return { context: loaded.context };
+    return { context: loaded.context, resolvedVia: "remote" };
 }
 
 const getRepoContext = async <RepoContext extends TaskRepoContext>({
     logger,
     taskTypeKey,
+    includeRemote = true,
 }: GetRepoContextParams): Promise<GetRepoContextResult<RepoContext>> => {
     const localEntry = localRepoRegistry.get(taskTypeKey);
     if (localEntry != null) {
-        logger.info("使用本地註冊的 Repo", { topic: "repo", context: { taskTypeKey } });
+        logger.info("使用本地註冊的 Repo", { topic: "repo", data: { taskTypeKey } });
         const context = await loadLocalEntry(logger, localEntry, taskTypeKey);
         if (context != null && isTaskRepoContext(context)) {
-            return { context: context as RepoContext };
+            return { context: context as RepoContext, resolvedVia: "local" };
         }
         const error = "本地 Repo 模組加載失敗或未導出有效的 TaskRepoContext";
-        logger.warn(error, { topic: "repo", context: { taskTypeKey } });
-        return { context: null, error };
+        logger.warn(error, { topic: "repo", data: { taskTypeKey } });
+        return { context: null, error, failureReason: "LOCAL_REPO_LOAD_FAILED" };
+    }
+
+    if (!includeRemote) {
+        const error = `本地未註冊 Repo (value=${taskTypeKey})`;
+        logger.warn(error, { topic: "repo", data: { taskTypeKey, includeRemote: false } });
+        return { context: null, error, failureReason: "LOCAL_REPO_NOT_FOUND" };
     }
 
     try {
         const result = await loadRemoteRepoContext(logger, taskTypeKey);
         if (result.context != null && isTaskRepoContext(result.context)) {
-            return { context: result.context as RepoContext };
+            return { context: result.context as RepoContext, resolvedVia: "remote" };
         }
         return {
             context: null,
             error: result.error ?? "遠程 Repo 上下文無效",
+            failureReason: result.failureReason ?? "REMOTE_REPO_LOAD_FAILED",
         };
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logger.error("從 Supabase 加載 Repo 失敗", {
             topic: "repo",
-            context: { taskTypeKey, error: message },
+            data: { taskTypeKey, error: message },
         });
-        return { context: null, error: message };
+        return { context: null, error: message, failureReason: "REMOTE_REPO_LOAD_FAILED" };
     }
 };
 
@@ -196,6 +219,10 @@ function unregisterLocalRepo(taskTypeKey: string): void {
     localRepoRegistry.delete(taskTypeKey);
 }
 
+function hasLocalRepo(taskTypeKey: string): boolean {
+    return localRepoRegistry.has(taskTypeKey);
+}
+
 function getRegisteredLocalTaskTypeKeys(): string[] {
     return [...localRepoRegistry.keys()];
 }
@@ -209,6 +236,7 @@ const RepoManager = {
     registerLocalRepoContext,
     registerLocalModule,
     unregisterLocalRepo,
+    hasLocalRepo,
     getRegisteredLocalTaskTypeKeys,
     clearRemoteContextCache,
     clearRepoScriptModuleCache,