@telorun/kernel 0.2.5 → 0.2.7

package/src/manifest-adapters/local-file-adapter.ts

@@ -1,7 +1,6 @@
+import type { ManifestAdapter } from "@telorun/analyzer";
 import * as fs from "fs/promises";
-import * as yaml from "js-yaml";
 import * as path from "path";
-import type { ManifestAdapter, ManifestSourceData } from "./manifest-adapter.js";
 
 export class LocalFileAdapter implements ManifestAdapter {
   supports(pathOrUrl: string): boolean {
@@ -9,58 +8,52 @@ export class LocalFileAdapter implements ManifestAdapter {
       pathOrUrl.startsWith("file://") ||
       pathOrUrl.startsWith("/") ||
       pathOrUrl.startsWith("./") ||
-      pathOrUrl.startsWith("../")
+      pathOrUrl.startsWith("../") ||
+      (!pathOrUrl.includes("://") && !pathOrUrl.includes("@"))
     );
   }
 
-  async read(pathOrUrl: string): Promise<ManifestSourceData> {
+  async read(pathOrUrl: string): Promise<{ text: string; source: string }> {
     const normalizedPath = pathOrUrl.startsWith("file://")
-      ? pathOrUrl.replace("file://", "")
+      ? new URL(pathOrUrl).pathname
       : pathOrUrl;
-    const stat = await fs.stat(normalizedPath);
-    const filePath = stat.isDirectory() ? path.join(normalizedPath, "module.yaml") : normalizedPath;
-    return this.readFile(filePath);
+    const resolvedPath = path.resolve(normalizedPath);
+    const stat = await fs.stat(resolvedPath);
+    const filePath = stat.isDirectory() ? path.join(resolvedPath, "module.yaml") : resolvedPath;
+    const text = await fs.readFile(filePath, "utf-8");
+    return { text, source: `file://${filePath}` };
   }
 
-  async readAll(pathOrUrl: string): Promise<ManifestSourceData[]> {
+  async readAll(pathOrUrl: string): Promise<string[]> {
     const normalizedPath = pathOrUrl.startsWith("file://")
-      ? pathOrUrl.replace("file://", "")
+      ? new URL(pathOrUrl).pathname
       : pathOrUrl;
-    const stat = await fs.stat(normalizedPath);
+    const resolvedPath = path.resolve(normalizedPath);
+    const stat = await fs.stat(resolvedPath);
     if (stat.isDirectory()) {
-      const results: ManifestSourceData[] = [];
-      await this.collectYamlFiles(normalizedPath, results);
-      return results;
+      return this.collectYamlSources(resolvedPath);
     }
-    return [await this.readFile(normalizedPath)];
+    return [`file://${resolvedPath}`];
   }
 
   resolveRelative(base: string, relative: string): string {
-    const basePath = base.startsWith("file://") ? base.slice("file://".length) : base;
-    return `file://${path.resolve(basePath, relative)}`;
+    const basePath = base.startsWith("file://") ? new URL(base).pathname : base;
+    const baseDir = basePath.endsWith("/") ? basePath : path.dirname(basePath);
+    return `file://${path.resolve(baseDir, relative)}`;
   }
 
-  private async readFile(filePath: string): Promise<ManifestSourceData> {
-    const content = await fs.readFile(filePath, "utf-8");
-
-    return {
-      documents: yaml.loadAll(content),
-      source: `file://${filePath}`,
-      baseDir: path.dirname(filePath),
-      uriBase: `file://localhost${filePath.replace(/\\/g, "/")}`,
-    };
-  }
-
-  private async collectYamlFiles(dirPath: string, results: ManifestSourceData[]): Promise<void> {
+  private async collectYamlSources(dirPath: string): Promise<string[]> {
+    const sources: string[] = [];
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(dirPath, entry.name);
       if (entry.isDirectory()) {
-        await this.collectYamlFiles(fullPath, results);
+        sources.push(...(await this.collectYamlSources(fullPath)));
       } else if (entry.isFile() && this.isYamlFile(entry.name)) {
-        results.push(await this.readFile(fullPath));
+        sources.push(`file://${fullPath}`);
       }
     }
+    return sources;
   }
 
   private isYamlFile(filename: string): boolean {

package/src/manifest-adapters/manifest-adapter.ts

@@ -1,4 +1,6 @@
 export interface ManifestSourceData {
+  /** Raw YAML text */
+  text: string;
   /** Parsed YAML documents (result of yaml.loadAll) */
   documents: any[];
   /** Stored as metadata.source (file path or URL) */

package/src/manifest-schemas.ts

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import AjvModule, { ErrorObject } from "ajv";
+import AjvModule from "ajv";
 import addFormats from "ajv-formats";
 const Ajv = AjvModule.default ?? AjvModule;
 
@@ -11,23 +11,62 @@ export const RuntimeResourceSchema = Type.Object(
   { additionalProperties: true },
 );
 
-export const ResourceDefinitionSchema = Type.Object(
-  {
-    kind: Type.Literal("Kernel.Definition"),
-    metadata: Type.Object(
-      {
-        name: Type.String(),
-        module: Type.Optional(Type.String()),
-      },
-      { additionalProperties: true },
-    ),
-    schema: Type.Object({}, { additionalProperties: true }),
-    capabilities: Type.Array(Type.String(), { minItems: 1 }),
-    events: Type.Optional(Type.Array(Type.String())),
-    controllers: Type.Optional(Type.Array(Type.String())),
+const metadataSchema = {
+  type: "object",
+  required: ["name"],
+  properties: {
+    name: { type: "string" },
+    module: { type: "string" },
   },
-  { additionalProperties: true },
-);
+  additionalProperties: true,
+};
+
+const baseDefinition = {
+  type: "object",
+  required: ["kind", "metadata"],
+  properties: {
+    kind: { const: "Kernel.Definition" },
+    metadata: metadataSchema,
+    capability: { type: "string" },
+    schema: { type: "object", additionalProperties: true },
+    controllers: { type: "array", items: { type: "string" } },
+  },
+  unevaluatedProperties: false,
+};
+
+const KNOWN_CAPABILITIES = [
+  "Kernel.Service",
+  "Kernel.Runnable",
+  "Kernel.Invocable",
+  "Kernel.Provider",
+  "Kernel.Type",
+  "Kernel.Mount",
+] as const;
+
+export const ResourceDefinitionSchema = {
+  ...baseDefinition,
+  oneOf: [
+    { required: ["capability"], properties: { capability: { const: "Kernel.Service" } } },
+    { required: ["capability"], properties: { capability: { const: "Kernel.Runnable" } } },
+    { required: ["capability"], properties: { capability: { const: "Kernel.Invocable" } } },
+    { required: ["capability"], properties: { capability: { const: "Kernel.Provider" } } },
+    { required: ["capability"], properties: { capability: { const: "Kernel.Type" } } },
+    {
+      required: ["capability"],
+      properties: {
+        capability: { const: "Kernel.Mount" },
+      },
+    },
+    // Unknown/absent capability: open schema for third-party extensibility
+    {
+      not: {
+        required: ["capability"],
+        properties: { capability: { enum: KNOWN_CAPABILITIES } },
+      },
+      unevaluatedProperties: true,
+    },
+  ],
+};
 
 const ajv = new Ajv({ allErrors: true, strict: false });
 addFormats.default(ajv);
@@ -35,15 +74,12 @@ addFormats.default(ajv);
 export const validateRuntimeResource = ajv.compile(RuntimeResourceSchema);
 export const validateResourceDefinition = ajv.compile(ResourceDefinitionSchema);
 
-export function formatAjvErrors(errors: ErrorObject[] | null | undefined): string {
-  if (!errors || errors.length === 0) {
-    return "Unknown schema error";
-  }
+export function formatAjvErrors(errors: any[] | null | undefined): string {
+  if (!errors || errors.length === 0) return "Unknown schema error";
   return errors
     .map((err) => {
-      const path = err.instancePath && err.instancePath.length > 0 ? err.instancePath : "/";
-      const message = err.message || "is invalid";
-      return `${path} ${message}`;
+      const p = err.instancePath || "/";
+      return `${p} ${err.message ?? "is invalid"}`;
     })
     .join("; ");
 }

package/src/resource-context.ts

@@ -5,6 +5,9 @@ import {
   ResourceContext,
   RuntimeError,
   RuntimeResource,
+  isCompiledValue,
+  type ParsedArgs,
+  type TypeRule,
 } from "@telorun/sdk";
 import AjvModule from "ajv";
 import addFormats from "ajv-formats";
@@ -15,16 +18,26 @@ import { SchemaValidator } from "./schema-valiator.js";
 const Ajv = AjvModule.default ?? AjvModule;
 
 export class ResourceContextImpl implements ResourceContext {
+  readonly stdin: NodeJS.ReadableStream;
+  readonly stdout: NodeJS.WritableStream;
+  readonly stderr: NodeJS.WritableStream;
+  readonly args: ParsedArgs;
+
   constructor(
     readonly kernel: Kernel,
     readonly moduleContext: ModuleContext,
     private readonly metadata: Record<string, any>,
     private readonly validator: SchemaValidator = new SchemaValidator(),
-  ) {}
-
-  stdin: NodeJS.ReadableStream = process.stdin;
-  stdout: NodeJS.WritableStream = process.stdout;
-  stderr: NodeJS.WritableStream = process.stderr;
+    stdin?: NodeJS.ReadableStream,
+    stdout?: NodeJS.WritableStream,
+    stderr?: NodeJS.WritableStream,
+    args?: ParsedArgs,
+  ) {
+    this.stdin = stdin ?? process.stdin;
+    this.stdout = stdout ?? process.stdout;
+    this.stderr = stderr ?? process.stderr;
+    this.args = args ?? { _: [] };
+  }
 
   createSchemaValidator(schema: any) {
     if (!schema) {
@@ -41,9 +54,56 @@ export class ResourceContextImpl implements ResourceContext {
     return this.validator.getSchema(name);
   }
 
+  registerTypeRules(name: string, rules: TypeRule[]): void {
+    this.validator.addTypeRules(name, rules);
+  }
+
+  lookupTypeRules(name: string): TypeRule[] | undefined {
+    return this.validator.getTypeRules(name);
+  }
+
+  createTypeValidator(typeRef: string | Record<string, any> | undefined) {
+    if (!typeRef) return new NoopValidator();
+
+    // String reference: look up registered type schema by name
+    if (typeof typeRef === "string") {
+      const schema = this.validator.getSchema(typeRef);
+      if (!schema) {
+        throw new RuntimeError(
+          "ERR_TYPE_NOT_FOUND",
+          `Type "${typeRef}" not found in schema registry`,
+        );
+      }
+      const base = this.validator.compile(schema);
+      const rules = this.validator.getTypeRules(typeRef);
+      if (rules && rules.length > 0) {
+        return this.validator.composeWithRules(base, typeRef, rules);
+      }
+      return base;
+    }
+
+    // Inline schema object: if it has a `schema` property, it's a type resource shape
+    if (typeRef.schema && typeof typeRef.schema === "object") {
+      const base = this.validator.compile(typeRef.schema);
+      const rules = Array.isArray(typeRef.rules) ? typeRef.rules : [];
+      if (rules.length > 0) {
+        return this.validator.composeWithRules(base, "inline", rules);
+      }
+      return base;
+    }
+
+    // Raw JSON Schema object (direct schema, not wrapped in type resource)
+    return this.validator.compile(typeRef);
+  }
+
   validateSchema(value: any, schema: any) {
-    const ajv = new Ajv();
+    const ajv = new Ajv({
+      removeAdditional: true,
+    });
     addFormats.default(ajv);
+    for (const kw of ["x-telo-ref", "x-telo-scope", "x-telo-context", "x-telo-schema-from"]) {
+      ajv.addKeyword(kw);
+    }
     const validate = ajv.compile(
       "type" in schema && typeof schema.type === "string"
         ? schema
@@ -54,17 +114,17 @@ export class ResourceContextImpl implements ResourceContext {
             additionalProperties: false,
           },
     );
-    const isValid = validate(value);
+    const isValid = validate(stripCompiledValues(value));
     if (!isValid) {
       throw new RuntimeError(
         "ERR_INVALID_VALUE",
-        `[${this.metadata.name}] Invalid value passed: ${JSON.stringify(value)}. Error: ${formatAjvErrors(validate.errors)}`,
+        `[${this.metadata.name}] Invalid value. Error: ${formatAjvErrors(validate.errors)}`,
       );
     }
   }
 
-  invoke(kind: string, name: string, ...args: any[]): Promise<any> {
-    return this.moduleContext.invoke(kind, name, ...args);
+  invoke<TInputs>(kind: string, name: string, inputs: TInputs): Promise<any> {
+    return this.moduleContext.invoke(kind, name, inputs);
   }
 
   async run(name: string) {
@@ -112,7 +172,7 @@ export class ResourceContextImpl implements ResourceContext {
       (k) => k !== "kind" && k !== "name" && k !== "metadata",
     );
 
-    if (definitionKeys.length > 0) {
+    if (definitionKeys.length > 0 && !this.moduleContext.hasManifest(name)) {
       this.registerManifest({
         ...resource,
         metadata: {
@@ -157,18 +217,6 @@ export class ResourceContextImpl implements ResourceContext {
     this.kernel.registerResourceDefinition(def);
   }
 
-  registerCapability(name: string, schema?: Record<string, any>): void {
-    this.kernel.registerCapability(name, schema);
-  }
-
-  isCapabilityRegistered(name: string): boolean {
-    return this.kernel.isCapabilityRegistered(name);
-  }
-
-  getCapabilitySchema(name: string): Record<string, any> | null | undefined {
-    return this.kernel.getCapabilitySchema(name);
-  }
-
   on(event: string, handler: (payload?: any) => void | Promise<void>): void {
     this.kernel.on(event, handler);
   }
@@ -193,18 +241,8 @@ export class ResourceContextImpl implements ResourceContext {
     this.kernel.requestExit(code);
   }
 
-  evaluateCel(expression: string, context: Record<string, any>): unknown {
-    return new EvaluationContext(
-      this.moduleContext.source,
-      context,
-      undefined,
-      new Set(),
-      this.emit,
-    ).evaluate(expression);
-  }
-
   expandValue(value: any, context: Record<string, any>) {
-    return this.moduleContext.merge(context).expand(value);
+    return this.moduleContext.expandWith(value, context);
   }
 
   async emitEvent(event: string, payload?: any) {
@@ -240,6 +278,10 @@ export class ResourceContextImpl implements ResourceContext {
     return this.moduleContext.spawnChild(child);
   }
 
+  transientChild(context: Record<string, any>): EvaluationContext {
+    return this.moduleContext.transientChild(context);
+  }
+
   /**
    * Create a temporary child context, queue manifests on it, run a function,
    * then tear down the child context and its resources.
@@ -259,8 +301,21 @@ export class ResourceContextImpl implements ResourceContext {
         await child.initializeResources();
         return await Promise.resolve(fn() as any);
       } finally {
-        await this.kernel.teardownContext(child);
+        await child.teardownResources();
       }
     })() as unknown as T;
   }
 }
+
+function stripCompiledValues(v: unknown): unknown {
+  if (isCompiledValue(v)) return "";
+  if (Array.isArray(v)) return v.map(stripCompiledValues);
+  if (v !== null && typeof v === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
+      out[k] = stripCompiledValues(val);
+    }
+    return out;
+  }
+  return v;
+}

package/src/schema-valiator.ts

@@ -1,4 +1,5 @@
-import { DataValidator, RuntimeError } from "@telorun/sdk";
+import { evaluate } from "@marcbachmann/cel-js";
+import { DataValidator, RuntimeError, TypeRule } from "@telorun/sdk";
 import AjvModule from "ajv";
 import addFormats from "ajv-formats";
 import { formatAjvErrors } from "./manifest-schemas.js";
@@ -7,6 +8,8 @@ const Ajv = AjvModule.default ?? AjvModule;
 
 export class SchemaValidator {
   private ajv: InstanceType<typeof Ajv>;
+  private typeRules = new Map<string, TypeRule[]>();
+  private rawSchemas = new Map<string, object>();
 
   constructor() {
     this.ajv = new Ajv({
@@ -15,36 +18,74 @@ export class SchemaValidator {
       useDefaults: true,
     });
     addFormats.default(this.ajv);
+    for (const kw of [
+      "x-telo-ref",
+      "x-telo-eval",
+      "x-telo-scope",
+      "x-telo-context",
+      "x-telo-context-from",
+      "x-telo-context-ref-from",
+      "x-telo-schema-from",
+      "x-telo-topology-role",
+      "x-telo-step-context",
+    ]) {
+      this.ajv.addKeyword(kw);
+    }
   }
 
   addSchema(name: string, schema: object): void {
     if (!this.ajv.getSchema(name)) {
       this.ajv.addSchema(schema, name);
     }
+    this.rawSchemas.set(name, schema);
   }
 
   getSchema(name: string): object | undefined {
-    return this.ajv.getSchema(name) as object | undefined;
+    return this.rawSchemas.get(name);
+  }
+
+  addTypeRules(name: string, rules: TypeRule[]): void {
+    this.typeRules.set(name, rules);
+  }
+
+  getTypeRules(name: string): TypeRule[] | undefined {
+    return this.typeRules.get(name);
   }
 
   compile(schema: any): DataValidator {
-    const validate = this.ajv.compile(
-      "type" in schema && typeof schema.type === "string"
-        ? schema
-        : {
-            type: "object",
-            properties: schema,
-            required: Object.keys(schema),
-            additionalProperties: false,
-          },
-    );
+    const isFullSchema =
+      ("type" in schema && typeof schema.type === "string") ||
+      "allOf" in schema ||
+      "anyOf" in schema ||
+      "oneOf" in schema ||
+      "$ref" in schema;
+    const normalized = isFullSchema
+      ? schema
+      : {
+          type: "object",
+          properties: schema,
+          required: Object.keys(schema),
+          additionalProperties: false,
+        };
+    const injected =
+      normalized.additionalProperties === false
+        ? {
+            ...normalized,
+            properties: {
+              kind: { type: "string" },
+              metadata: { type: "object" },
+              ...normalized.properties,
+            },
+          }
+        : normalized;
+    const validate = this.ajv.compile(injected);
 
     return {
       validate: (data: any) => {
         const isValid = validate(data);
         if (!isValid) {
           throw new RuntimeError(
-            "ERR_RESOURCE_NOT_FOUND",
+            "ERR_RESOURCE_SCHEMA_VALIDATION_FAILED",
             `Invalid value passed: ${JSON.stringify(data)}. Error: ${formatAjvErrors(validate.errors)}`,
           );
         }
@@ -54,4 +95,40 @@ export class SchemaValidator {
       },
     };
   }
+
+  composeWithRules(base: DataValidator, typeName: string, rules: TypeRule[]): DataValidator {
+    return {
+      validate: (data: any) => {
+        base.validate(data);
+        for (const rule of rules) {
+          let result: unknown;
+          try {
+            result = evaluate(rule.condition, { this: data });
+          } catch (err) {
+            throw new RuntimeError(
+              "ERR_TYPE_VALIDATION_FAILED",
+              `Type "${typeName}" rule evaluation failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+          }
+          if (result !== true) {
+            throw new RuntimeError(
+              rule.code ?? "ERR_TYPE_VALIDATION_FAILED",
+              rule.message ?? `Type "${typeName}" validation failed: rule "${rule.code}" not satisfied`,
+            );
+          }
+        }
+      },
+      isValid: (data: any) => {
+        if (!base.isValid(data)) return false;
+        for (const rule of rules) {
+          try {
+            if (evaluate(rule.condition, { this: data }) !== true) return false;
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      },
+    };
+  }
 }

package/src/capabilities/component.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: component

package/src/capabilities/executable.yaml

@@ -1,8 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: executable
-schema:
-  type: object
-  properties:
-    foo: { type: string }

package/src/capabilities/handler.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: handler

package/src/capabilities/listener.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: listener

package/src/capabilities/provider.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: provider

package/src/capabilities/template.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: template

package/src/capabilities/type.yaml

@@ -1,4 +0,0 @@
-kind: Kernel.Capability
-metadata:
-  module: Kernel
-  name: type

package/src/controllers/capability/capability-controller.ts

@@ -1,41 +0,0 @@
-import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
-
-type CapabilityResource = {
-  kind: string;
-  metadata: {
-    name: string;
-    [key: string]: any;
-  };
-  schema?: Record<string, any>;
-};
-
-class Capability implements ResourceInstance {
-  constructor(private readonly resource: CapabilityResource) {}
-
-  async init(ctx: ResourceContext) {
-    ctx.registerCapability(this.resource.metadata.name, this.resource.schema);
-  }
-}
-
-export async function create(resource: any, _ctx: ResourceContext): Promise<Capability> {
-  return new Capability(resource as CapabilityResource);
-}
-
-export const schema = {
-  type: "object",
-  properties: {
-    metadata: {
-      type: "object",
-      properties: {
-        name: { type: "string" },
-      },
-      required: ["name"],
-    },
-    schema: {
-      type: "object",
-      additionalProperties: true,
-    },
-  },
-  required: ["metadata"],
-  additionalProperties: true,
-};

package/src/controllers/module/module.json

@@ -1,48 +0,0 @@
-{
-  "type": "object",
-  "properties": {
-    "metadata": {
-      "type": "object",
-      "properties": {
-        "name": {
-          "type": "string"
-        }
-      },
-      "required": ["name"]
-    },
-    "imports": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Paths to other modules to import"
-    },
-    "definitions": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Paths to ResourceDefinition files"
-    },
-    "resources": {
-      "type": "array",
-      "items": {
-        "oneOf": [
-          {
-            "type": "string"
-          },
-          {
-            "type": "object",
-            "properties": {
-              "path": {
-                "type": "string"
-              }
-            }
-          }
-        ]
-      },
-      "description": "Paths to resource instance files to load"
-    }
-  },
-  "required": ["metadata"]
-}