veryfront 0.1.76 → 0.1.78

package/src/cli/shared/project-source-context.ts

@@ -0,0 +1,96 @@
+import { getConfig, type VeryfrontConfig } from "../../src/config/index.js";
+import {
+  enhanceAdapterWithFS,
+  getEnv,
+  isExtendedFSAdapter,
+  runtime,
+  type RuntimeAdapter,
+} from "../../src/platform/index.js";
+
+interface ProxyProjectSourceContext {
+  projectSlug: string;
+  token: string;
+  projectId?: string;
+  branchRef?: string | null;
+}
+
+export interface ProjectSourceExecutionContext {
+  adapter: RuntimeAdapter;
+  config: VeryfrontConfig;
+  projectDir: string;
+  projectId?: string;
+  proxyContext?: ProxyProjectSourceContext;
+}
+
+function getProxyProjectSourceContext(): ProxyProjectSourceContext | null {
+  const projectSlug = getEnv("VERYFRONT_PROJECT_SLUG")?.trim();
+  const token = getEnv("VERYFRONT_API_TOKEN")?.trim();
+
+  if (!projectSlug || !token) {
+    return null;
+  }
+
+  const projectId = getEnv("VERYFRONT_PROJECT_ID")?.trim();
+  const branchRef = getEnv("VERYFRONT_BRANCH_REF")?.trim();
+
+  return {
+    projectSlug,
+    token,
+    projectId: projectId || undefined,
+    branchRef: branchRef || null,
+  };
+}
+
+async function loadProjectConfig(
+  projectDir: string,
+  adapter: RuntimeAdapter,
+  proxyContext?: ProxyProjectSourceContext,
+): Promise<VeryfrontConfig> {
+  const cacheKey = proxyContext?.projectId ?? proxyContext?.projectSlug;
+  return await getConfig(projectDir, adapter, cacheKey ? { cacheKey } : undefined);
+}
+
+export async function withProjectSourceContext<T>(
+  projectDir: string,
+  run: (context: ProjectSourceExecutionContext) => Promise<T>,
+): Promise<T> {
+  const baseAdapter = await runtime.get();
+  const initialConfig = await getConfig(projectDir, baseAdapter);
+  const adapter = await enhanceAdapterWithFS(baseAdapter, initialConfig, projectDir);
+  const proxyContext = getProxyProjectSourceContext();
+
+  if (
+    proxyContext &&
+    isExtendedFSAdapter(adapter.fs) &&
+    adapter.fs.isMultiProjectMode()
+  ) {
+    return await adapter.fs.runWithContext(
+      proxyContext.projectSlug,
+      proxyContext.token,
+      async () => {
+        const config = await loadProjectConfig(projectDir, adapter, proxyContext);
+        return await run({
+          adapter,
+          config,
+          projectDir,
+          projectId: proxyContext.projectId,
+          proxyContext,
+        });
+      },
+      proxyContext.projectId,
+      {
+        productionMode: false,
+        branch: proxyContext.branchRef ?? null,
+      },
+    );
+  }
+
+  const config = await loadProjectConfig(projectDir, adapter);
+  return await run({
+    adapter,
+    config,
+    projectDir,
+    projectId: proxyContext?.projectId,
+    proxyContext: proxyContext ?? undefined,
+  });
+}

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [
@@ -114,6 +114,7 @@ export default {
     "#cli/shared/types": "./cli/shared/types.ts",
     "#cli/shared/constants": "./cli/shared/constants.ts",
     "#cli/shared/config": "./cli/shared/config.ts",
+    "#cli/shared/project-source-context": "./cli/shared/project-source-context.ts",
     "#cli/shared/slug": "./cli/shared/slug.ts",
     "#cli/shared/reserve-slug": "./cli/shared/reserve-slug.ts",
     "#cli/shared/server-startup": "./cli/shared/server-startup.ts",

package/src/src/discovery/module-import.ts

@@ -0,0 +1,36 @@
+import type { RuntimeAdapter } from "../platform/index.js";
+import { detectPlatform } from "../platform/core-platform.js";
+import * as pathHelper from "../platform/compat/path/index.js";
+import { importModule } from "./transpiler.js";
+
+interface ImportDiscoveryModuleOptions {
+  adapter: RuntimeAdapter;
+  projectDir?: string;
+}
+
+function normalizeModulePath(filePath: string): string {
+  return filePath.startsWith("file://") ? filePath : `file://${filePath}`;
+}
+
+function resolveModulePath(filePath: string, projectDir?: string): string {
+  if (filePath.startsWith("file://")) return filePath;
+  if (pathHelper.isAbsolute(filePath)) return normalizeModulePath(filePath);
+  if (!projectDir || projectDir === "." || projectDir === "") {
+    return normalizeModulePath(`/${filePath.replace(/^\/+/, "")}`);
+  }
+
+  return normalizeModulePath(pathHelper.join(projectDir, filePath));
+}
+
+export async function importDiscoveryModule(
+  filePath: string,
+  options: ImportDiscoveryModuleOptions,
+): Promise<Record<string, unknown>> {
+  const module = await importModule(resolveModulePath(filePath, options.projectDir), {
+    platform: detectPlatform(),
+    fsAdapter: options.adapter.fs,
+    baseDir: options.projectDir || ".",
+  });
+
+  return module as Record<string, unknown>;
+}

package/src/src/platform/adapters/veryfront-api-client/operations.ts

@@ -154,14 +154,13 @@ export class VeryfrontAPIOperations {
 
   async listBranchFiles(
     projectRef: string,
-    branchName = "main",
+    branchRef = "main",
     options: ListFilesOptions = {},
   ): Promise<FileListResult> {
     const params = buildListParams(options);
-    const url = `/projects/${encodeURIComponent(projectRef)}/branches/${
-      encodeURIComponent(branchName)
-    }/files?${params}`;
-    logger.debug("listBranchFiles", { projectRef, branchName, pattern: options.pattern });
+    params.set("branch", branchRef);
+    const url = `/projects/${encodeURIComponent(projectRef)}/files?${params}`;
+    logger.debug("listBranchFiles", { projectRef, branchRef, pattern: options.pattern });
 
     const raw = await this.request(url);
     const response = ListBranchFilesResponseSchema.parse(raw);
@@ -174,11 +173,11 @@ export class VeryfrontAPIOperations {
 
   async listAllBranchFiles(
     projectRef: string,
-    branchName = "main",
+    branchRef = "main",
     options: Omit<ListFilesOptions, "cursor"> = {},
   ): Promise<ProjectFile[]> {
     const allFiles = await listAllFiles((cursor) =>
-      this.listBranchFiles(projectRef, branchName, {
+      this.listBranchFiles(projectRef, branchRef, {
         ...options,
         cursor,
         limit: DEFAULT_PAGE_LIMIT,
@@ -187,21 +186,22 @@ export class VeryfrontAPIOperations {
 
     logger.debug("listAllBranchFiles DONE", {
       projectRef,
-      branchName,
+      branchRef,
       totalFiles: allFiles.length,
     });
 
     return allFiles;
   }
 
-  getBranchFile(projectRef: string, branchName: string, pathOrId: string): Promise<FileDetail> {
+  getBranchFile(projectRef: string, branchRef: string, pathOrId: string): Promise<FileDetail> {
     return withSpan(
       SpanNames.API_GET_FILE,
       async () => {
-        const url = `/projects/${encodeURIComponent(projectRef)}/branches/${
-          encodeURIComponent(branchName)
-        }/files/${encodeURIComponent(pathOrId)}`;
-        logger.debug("getBranchFile", { projectRef, branchName, pathOrId });
+        const params = new URLSearchParams({ branch: branchRef });
+        const url = `/projects/${encodeURIComponent(projectRef)}/files/${
+          encodeURIComponent(pathOrId)
+        }?${params}`;
+        logger.debug("getBranchFile", { projectRef, branchRef, pathOrId });
 
         const raw = await this.request(url);
         const response = BranchFileDetailSchema.parse(raw);
@@ -217,7 +217,7 @@ export class VeryfrontAPIOperations {
       {
         "api.operation": "getBranchFile",
         "api.project": projectRef,
-        "api.branch": branchName,
+        "api.branch": branchRef,
         "api.path": pathOrId,
       },
     );

package/src/src/platform/adapters/veryfront-api-client/schemas/api.schema.ts

@@ -179,13 +179,13 @@ export const API_ENDPOINTS = {
   },
   listBranchFiles: {
     method: "GET" as const,
-    path: "/projects/{projectRef}/branches/{branchName}/files",
-    description: "List files in a branch (draft/working copy)",
+    path: "/projects/{projectRef}/files?branch={branchRef}",
+    description: "List files for a branch ref or name (omit branch for main branch)",
   },
   getBranchFile: {
     method: "GET" as const,
-    path: "/projects/{projectRef}/branches/{branchName}/files/{pathOrId}",
-    description: "Get file from a branch by path or UUID",
+    path: "/projects/{projectRef}/files/{pathOrId}?branch={branchRef}",
+    description: "Get file from a branch ref or name by path or UUID",
   },
   listEnvironmentFiles: {
     method: "GET" as const,

package/src/src/platform/index.ts

@@ -66,6 +66,7 @@ export { isDeno } from "./compat/runtime.js";
 
 // Adapters: filesystem
 export { createFSAdapter, VeryfrontFSAdapter } from "./adapters/fs/index.js";
+export { enhanceAdapterWithFS, isExtendedFSAdapter } from "./adapters/fs/index.js";
 
 // Adapters: API client
 export { VeryfrontApiClient } from "./adapters/veryfront-api-client/index.js";

package/src/src/server/runtime-handler/index.ts

@@ -55,7 +55,6 @@ import { MarkdownPreviewHandler } from "../handlers/preview/markdown-preview.han
 import { OpenAPIHandler } from "../handlers/request/openapi.handler.js";
 import { OpenAPIDocsHandler } from "../handlers/request/openapi-docs.handler.js";
 import { InternalAgentsListHandler } from "../handlers/request/internal-agents-list.handler.js";
-import { InternalTasksListHandler } from "../handlers/request/internal-tasks-list.handler.js";
 import { AgentStreamHandler } from "../handlers/request/agent-stream.handler.js";
 import { AgentRunResumeHandler } from "../handlers/request/agent-run-resume.handler.js";
 import { AgentRunCancelHandler } from "../handlers/request/agent-run-cancel.handler.js";
@@ -132,7 +131,6 @@ export const HANDLER_NAMES = [
   "OpenAPIHandler",
   "OpenAPIDocsHandler",
   "InternalAgentsListHandler",
-  "InternalTasksListHandler",
   "AgentStreamHandler",
   "AgentRunResumeHandler",
   "AgentRunCancelHandler",
@@ -187,7 +185,6 @@ const handlerFactories: Record<
   OpenAPIHandler: () => new OpenAPIHandler(),
   OpenAPIDocsHandler: () => new OpenAPIDocsHandler(),
   InternalAgentsListHandler: () => new InternalAgentsListHandler(),
-  InternalTasksListHandler: () => new InternalTasksListHandler(),
   AgentStreamHandler: () => new AgentStreamHandler(),
   AgentRunResumeHandler: () => new AgentRunResumeHandler(),
   AgentRunCancelHandler: () => new AgentRunCancelHandler(),

package/src/src/task/discovery.ts

@@ -25,7 +25,7 @@ import { logger as baseLogger } from "../utils/index.js";
 import type { RuntimeAdapter } from "../platform/index.js";
 import type { VeryfrontConfig } from "../config/index.js";
 import { collectFiles } from "../utils/file-discovery.js";
-import { loadHandlerModule } from "../routing/api/module-loader/loader.js";
+import { importDiscoveryModule } from "../discovery/module-import.js";
 import type { TaskDefinition } from "./types.js";
 import { isTaskDefinition } from "./types.js";
 
@@ -144,17 +144,13 @@ export async function discoverTasks(
 
     for (const file of files) {
       try {
-        const module = await loadHandlerModule({
-          projectDir,
-          modulePath: file.path,
+        const module = await importDiscoveryModule(file.path, {
           adapter,
-          config,
+          projectDir,
         });
 
-        if (!module) continue;
-
         // Prefer default export (aligned with discovery-engine behaviour)
-        const defaultExport = (module as Record<string, unknown>).default;
+        const defaultExport = module.default;
         if (isTaskDefinition(defaultExport)) {
           const id = deriveTaskId(file.path, baseDir);
           tasks.push({
@@ -248,16 +244,12 @@ export async function findTaskById(
       if (id !== taskId) continue;
 
       try {
-        const module = await loadHandlerModule({
-          projectDir,
-          modulePath: file.path,
+        const module = await importDiscoveryModule(file.path, {
           adapter,
-          config,
+          projectDir,
         });
 
-        if (!module) continue;
-
-        const defaultExport = (module as Record<string, unknown>).default;
+        const defaultExport = module.default;
         if (isTaskDefinition(defaultExport)) {
           if (debug) {
             logger.info(`Found task "${id}" in ${file.path} (export: default)`);

package/src/src/workflow/discovery/workflow-discovery.ts

@@ -27,7 +27,7 @@ import { logger as baseLogger } from "../../utils/index.js";
 import type { RuntimeAdapter } from "../../platform/index.js";
 import type { VeryfrontConfig } from "../../config/index.js";
 import { collectFiles } from "../../utils/file-discovery.js";
-import { loadHandlerModule } from "../../routing/api/module-loader/loader.js";
+import { importDiscoveryModule } from "../../discovery/module-import.js";
 import type { WorkflowDefinition } from "../types.js";
 
 const logger = baseLogger.component("workflow-discovery");
@@ -167,17 +167,11 @@ export async function discoverWorkflows(
     // Load and extract workflows from each file
     for (const file of files) {
       try {
-        const module = await loadHandlerModule({
-          projectDir,
-          modulePath: file.path,
+        const module = await importDiscoveryModule(file.path, {
           adapter,
-          config,
+          projectDir,
         });
 
-        if (!module) {
-          continue;
-        }
-
         // Extract workflows from module exports
         for (const [exportName, value] of Object.entries(module)) {
           const definition = extractWorkflowDefinition(value);

package/esm/src/server/handlers/request/internal-tasks-list.handler.d.ts

@@ -1,11 +0,0 @@
-import * as dntShim from "../../../../_dnt.shims.js";
-import { type RuntimeTaskDiscoveryDeps } from "../../../task/control-plane.js";
-import { BaseHandler } from "../response/base.js";
-import type { HandlerContext, HandlerMetadata, HandlerResult } from "../types.js";
-export declare class InternalTasksListHandler extends BaseHandler {
-    private readonly deps;
-    metadata: HandlerMetadata;
-    constructor(deps?: RuntimeTaskDiscoveryDeps);
-    handle(req: dntShim.Request, ctx: HandlerContext): Promise<HandlerResult>;
-}
-//# sourceMappingURL=internal-tasks-list.handler.d.ts.map

package/esm/src/server/handlers/request/internal-tasks-list.handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal-tasks-list.handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/server/handlers/request/internal-tasks-list.handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAKL,KAAK,wBAAwB,EAC9B,MAAM,gCAAgC,CAAC;AAUxC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnG,qBAAa,wBAAyB,SAAQ,WAAW;IAQrD,OAAO,CAAC,QAAQ,CAAC,IAAI;IAPvB,QAAQ,EAAE,eAAe,CAIvB;gBAGiB,IAAI,GAAE,wBAA0D;IAK7E,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAmEhF"}

package/esm/src/server/handlers/request/internal-tasks-list.handler.js

@@ -1,72 +0,0 @@
-import { PRIORITY_MEDIUM_API } from "../../../utils/constants/index.js";
-import { ZodError } from "zod";
-import { ControlPlaneTasksListRequestSchema, defaultRuntimeTaskDiscoveryDeps, listRuntimeTasks, } from "../../../task/control-plane.js";
-import { ControlPlaneRequestError, verifyControlPlaneRequest, } from "../../../internal-agents/control-plane-auth.js";
-import { INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES, InternalAgentRequestBodyTooLargeError, readInternalAgentRequestBody, } from "../../../internal-agents/request-body.js";
-import { BaseHandler } from "../response/base.js";
-export class InternalTasksListHandler extends BaseHandler {
-    deps;
-    metadata = {
-        name: "InternalTasksListHandler",
-        priority: PRIORITY_MEDIUM_API,
-        patterns: [{ pattern: "/internal/tasks/list", exact: true, method: "POST" }],
-    };
-    constructor(deps = defaultRuntimeTaskDiscoveryDeps) {
-        super();
-        this.deps = deps;
-    }
-    async handle(req, ctx) {
-        if (!this.shouldHandle(req, ctx)) {
-            return this.continue();
-        }
-        return this.withProxyContext(ctx, async () => {
-            const builder = this.createResponseBuilder(ctx)
-                .withCORS(req, ctx.securityConfig?.cors)
-                .withSecurity(ctx.securityConfig ?? undefined, req);
-            try {
-                const rawBody = await readInternalAgentRequestBody(req, INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES);
-                const payload = ControlPlaneTasksListRequestSchema.parse(JSON.parse(rawBody));
-                const claims = await verifyControlPlaneRequest(req, ctx, rawBody, {
-                    expectedSubject: payload.requestId,
-                    expectedSurface: payload.surface,
-                });
-                if (payload.projectId !== claims.project_id ||
-                    (ctx.projectId !== undefined && payload.projectId !== ctx.projectId)) {
-                    this.logWarn("Internal tasks list request body did not match signed claims", {
-                        projectSlug: ctx.projectSlug,
-                        projectId: ctx.projectId,
-                        requestId: payload.requestId,
-                        signedRequestId: claims.sub,
-                        surface: payload.surface,
-                        signedSurface: claims.surface,
-                    });
-                    return this.respond(builder.json({ error: "Invalid control-plane signature" }, 401));
-                }
-                const response = await listRuntimeTasks(ctx, this.deps);
-                return this.respond(builder.json(response, 200));
-            }
-            catch (error) {
-                if (error instanceof InternalAgentRequestBodyTooLargeError) {
-                    return this.respond(builder.json({ error: error.message }, error.status));
-                }
-                if (error instanceof ControlPlaneRequestError) {
-                    this.logWarn("Internal tasks list signature verification failed", {
-                        error: error.message,
-                        projectSlug: ctx.projectSlug,
-                        projectId: ctx.projectId,
-                    });
-                    return this.respond(builder.json({ error: error.message }, error.status));
-                }
-                if (error instanceof SyntaxError || error instanceof ZodError) {
-                    this.logWarn("Internal tasks list request validation failed", {
-                        error: error instanceof Error ? error.message : String(error),
-                        projectSlug: ctx.projectSlug,
-                        projectId: ctx.projectId,
-                    });
-                    return this.respond(builder.json({ error: "Invalid internal tasks request" }, 400));
-                }
-                throw error;
-            }
-        });
-    }
-}

package/esm/src/task/control-plane.d.ts

@@ -1,105 +0,0 @@
-import type { HandlerContext } from "../types/index.js";
-import { z } from "zod";
-import { discoverTasks, type TaskDiscoveryOptions } from "./discovery.js";
-export declare const ControlPlaneTasksListRequestSchema: z.ZodObject<{
-    requestId: z.ZodString;
-    projectId: z.ZodString;
-    surface: z.ZodEnum<["studio", "channels", "a2a", "mcp"]>;
-}, "strip", z.ZodTypeAny, {
-    requestId: string;
-    projectId: string;
-    surface: "mcp" | "studio" | "channels" | "a2a";
-}, {
-    requestId: string;
-    projectId: string;
-    surface: "mcp" | "studio" | "channels" | "a2a";
-}>;
-export declare const RuntimeTaskSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    target: z.ZodString;
-    sourcePath: z.ZodString;
-    inputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    outputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    schedulable: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    description: string | null;
-    name: string;
-    id: string;
-    target: string;
-    sourcePath: string;
-    outputSchema: Record<string, unknown> | null;
-    inputSchema: Record<string, unknown> | null;
-    schedulable: boolean;
-}, {
-    description: string | null;
-    name: string;
-    id: string;
-    target: string;
-    sourcePath: string;
-    outputSchema: Record<string, unknown> | null;
-    inputSchema: Record<string, unknown> | null;
-    schedulable: boolean;
-}>;
-export declare const RuntimeTaskListResponseSchema: z.ZodObject<{
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        target: z.ZodString;
-        sourcePath: z.ZodString;
-        inputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        outputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        schedulable: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        description: string | null;
-        name: string;
-        id: string;
-        target: string;
-        sourcePath: string;
-        outputSchema: Record<string, unknown> | null;
-        inputSchema: Record<string, unknown> | null;
-        schedulable: boolean;
-    }, {
-        description: string | null;
-        name: string;
-        id: string;
-        target: string;
-        sourcePath: string;
-        outputSchema: Record<string, unknown> | null;
-        inputSchema: Record<string, unknown> | null;
-        schedulable: boolean;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    tasks: {
-        description: string | null;
-        name: string;
-        id: string;
-        target: string;
-        sourcePath: string;
-        outputSchema: Record<string, unknown> | null;
-        inputSchema: Record<string, unknown> | null;
-        schedulable: boolean;
-    }[];
-}, {
-    tasks: {
-        description: string | null;
-        name: string;
-        id: string;
-        target: string;
-        sourcePath: string;
-        outputSchema: Record<string, unknown> | null;
-        inputSchema: Record<string, unknown> | null;
-        schedulable: boolean;
-    }[];
-}>;
-export type ControlPlaneTasksListRequest = z.infer<typeof ControlPlaneTasksListRequestSchema>;
-export type RuntimeTask = z.infer<typeof RuntimeTaskSchema>;
-export type RuntimeTaskListResponse = z.infer<typeof RuntimeTaskListResponseSchema>;
-export interface RuntimeTaskDiscoveryDeps {
-    discoverTasks: (options: TaskDiscoveryOptions) => ReturnType<typeof discoverTasks>;
-}
-export declare const defaultRuntimeTaskDiscoveryDeps: RuntimeTaskDiscoveryDeps;
-export declare function listRuntimeTasks(ctx: HandlerContext, deps?: RuntimeTaskDiscoveryDeps): Promise<RuntimeTaskListResponse>;
-//# sourceMappingURL=control-plane.d.ts.map

package/esm/src/task/control-plane.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-plane.d.ts","sourceRoot":"","sources":["../../../src/src/task/control-plane.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE1E,eAAO,MAAM,kCAAkC;;;;;;;;;;;;EAI7C,CAAC;AAIH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS5B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAExC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAC9F,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;CACpF;AAED,eAAO,MAAM,+BAA+B,EAAE,wBAE7C,CAAC;AAUF,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,cAAc,EACnB,IAAI,GAAE,wBAA0D,GAC/D,OAAO,CAAC,uBAAuB,CAAC,CAwBlC"}

package/esm/src/task/control-plane.js

@@ -1,52 +0,0 @@
-import { ControlPlaneSurfaceSchema } from "../channels/control-plane.js";
-import { z } from "zod";
-import { discoverTasks } from "./discovery.js";
-export const ControlPlaneTasksListRequestSchema = z.object({
-    requestId: z.string().min(1),
-    projectId: z.string().min(1),
-    surface: ControlPlaneSurfaceSchema,
-});
-const JsonSchemaRecordSchema = z.record(z.unknown());
-export const RuntimeTaskSchema = z.object({
-    id: z.string().min(1),
-    name: z.string().min(1),
-    description: z.string().nullable(),
-    target: z.string().min(1),
-    sourcePath: z.string().min(1),
-    inputSchema: JsonSchemaRecordSchema.nullable(),
-    outputSchema: JsonSchemaRecordSchema.nullable(),
-    schedulable: z.boolean(),
-});
-export const RuntimeTaskListResponseSchema = z.object({
-    tasks: z.array(RuntimeTaskSchema),
-});
-export const defaultRuntimeTaskDiscoveryDeps = {
-    discoverTasks,
-};
-function normalizeJsonSchema(value) {
-    if (value == null || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    return value;
-}
-export async function listRuntimeTasks(ctx, deps = defaultRuntimeTaskDiscoveryDeps) {
-    const discovery = await deps.discoverTasks({
-        projectDir: ctx.projectDir,
-        adapter: ctx.adapter,
-        config: ctx.config,
-        debug: ctx.debug ?? false,
-    });
-    const tasks = discovery.tasks
-        .map((task) => RuntimeTaskSchema.parse({
-        id: task.id,
-        name: task.name,
-        description: task.definition.description ?? null,
-        target: `task:${task.id}`,
-        sourcePath: task.filePath,
-        inputSchema: normalizeJsonSchema(task.definition.inputSchema),
-        outputSchema: normalizeJsonSchema(task.definition.outputSchema),
-        schedulable: task.definition.schedulable ?? true,
-    }))
-        .sort((left, right) => left.name.localeCompare(right.name));
-    return RuntimeTaskListResponseSchema.parse({ tasks });
-}