@katmer/core 0.0.3

package/lib/interfaces/task.interface.ts

@@ -0,0 +1,100 @@
+import type { KatmerProvider } from "./provider.interface"
+import type { KatmerConfig } from "./config.interface"
+import type { TwigExpression } from "./executor.interface"
+import type { Logger } from "pino"
+import type { ProviderResponse } from "../providers/provider_response"
+import { KatmerModule } from "../module"
+
+export namespace Katmer {
+  /*
+   * For plugins
+   */
+  export interface CustomInclude {
+    [key: string]: unknown
+  }
+
+  export type IncludeConfig =
+    | string
+    | {
+        file: string
+      }
+    | {
+        remote: string
+      }
+    | CustomInclude
+
+  /*
+   * For plugins
+   */
+  export interface TaskActions {}
+
+  export interface TaskContext<
+    Provider extends KatmerProvider = KatmerProvider
+  > {
+    exec: (
+      command: string,
+      options?: Parameters<Provider["executor"]>[0]
+    ) => Promise<ProviderResponse>
+    execSafe: (
+      command: string,
+      options?: Parameters<Provider["executor"]>[0]
+    ) => Promise<ProviderResponse>
+    config: KatmerConfig
+    provider: Provider
+    variables: Record<string, any>
+    progress: (data: Record<string, any>) => void
+    logger: Logger
+    log: (
+      level: "fatal" | "error" | "warn" | "info" | "debug" | "trace",
+      ...message: any
+    ) => void
+
+    warn(opts: { message: string }): void
+    warn(msg: string): void
+
+    fail(msg: string): never
+    fail(opts: { message: string }): never
+  }
+
+  export interface RuleVariables {
+    [key: string]: string
+  }
+
+  export interface UntilControl {
+    condition: string | TwigExpression
+    delay?: number
+    retries?: number
+  }
+  export interface LoopControl {
+    for: TwigExpression | (boolean | number | string)[]
+    loop_var?: string
+    index_var?: string
+    pause?: number
+    break_when?: string | TwigExpression | (string | TwigExpression)[]
+    label?: string | TwigExpression
+    extended?: boolean
+    extended_allitems?: boolean
+  }
+
+  export interface TaskRule {
+    loop?: LoopControl | LoopControl["for"]
+    until?: UntilControl | UntilControl["condition"]
+    when?: string
+    register?: string
+    allow_failure?: boolean
+    variables?: RuleVariables
+    environment?: string | Record<string, string>
+  }
+
+  export interface Task extends TaskActions, TaskRule {
+    name?: string
+    targets: string[]
+    script?: string[]
+  }
+
+  export type Config = {
+    include?: IncludeConfig[]
+  } & {
+    [key: string]: Task
+  }
+}

package/lib/katmer.ts

@@ -0,0 +1,126 @@
+import { parseKatmerFile, readKatmerFile } from "./utils/file.utils"
+import type {
+  KatmerConfig,
+  KatmerCLIOptions,
+  StandardLogger
+} from "./interfaces/config.interface"
+import { KatmerTargetResolver } from "./target_resolver"
+import "./module_registry"
+import { KatmerModuleRegistry } from "./module_registry"
+import * as pino from "pino"
+import pinoPretty from "pino-pretty"
+import { KatmerConfigLoader } from "./config"
+import { evalExpr } from "./utils/renderer/renderer"
+import type { ModuleCommonReturn } from "./interfaces/module.interface"
+import { wrapInArray } from "./utils/json.utils"
+import { defaults, isObjectLike } from "es-toolkit/compat"
+import type { Katmer } from "./interfaces/task.interface"
+import { KatmerTask } from "./task/task"
+
+export interface KatmerInitOptions extends KatmerCLIOptions {
+  logging?: {
+    dir?: string
+    level?: "trace" | "debug" | "info" | "warn" | "error" | "silent"
+  }
+}
+
+export class KatmerCore {
+  config!: KatmerConfig
+  registry!: KatmerModuleRegistry
+  logger!: StandardLogger
+  constructor(private opts: KatmerCLIOptions) {}
+
+  async init() {
+    await this.loadConfig()
+    this.initLogger()
+    this.initRegistry()
+  }
+
+  async loadConfig(config?: Partial<KatmerConfig>) {
+    if (config) {
+      this.config = KatmerConfigLoader.validate(config)
+    } else {
+      const { target, cwd } = this.opts
+      this.config = await KatmerConfigLoader.load(target, { cwd })
+    }
+  }
+
+  initRegistry() {
+    this.registry = new KatmerModuleRegistry(this)
+  }
+
+  initLogger() {
+    this.logger = pino.pino(
+      {
+        formatters: {
+          bindings() {
+            return {}
+          }
+        },
+        level: this.config.logging?.level || "trace",
+        timestamp: pino.stdTimeFunctions.isoTime
+      },
+      pinoPretty({
+        colorizeObjects: true,
+        singleLine: false,
+        useOnlyCustomProps: true,
+        colorize: true,
+        ignore: "provider,module",
+
+        customPrettifiers: {
+          command: (output, keyName, logObj, extras) => `${output}`,
+          provider: (output, keyName, logObj, extras) => `${output}`,
+          module: (output, keyName, logObj, extras) => `${output}`
+        }
+      })
+    )
+    // TODO: initialize logger
+    // new ConsoleReadableStream().pipeTo(
+    //   new WritableStream({
+    //     write(log) {
+    //       appendFile(logFile, `${JSON.stringify(log)}\n`)
+    //       Bun.write(Bun.stdout, `${JSON.stringify(log)}\n`)
+    //       for (const client of clients) {
+    //         client.send(new WSMessage("log", log as any))
+    //       }
+    //     }
+    //   })
+    // )
+  }
+  async check() {
+    await using targetResolver = new KatmerTargetResolver(this)
+    const providers = targetResolver.resolveTargets("all")
+    console.log(targetResolver.hosts)
+    console.log(this.config, providers)
+    for (const runFor of providers) {
+      const provider = await targetResolver.resolveProvider(runFor)
+      await provider.ensureReady()
+    }
+  }
+
+  async run(file: string) {
+    const contents = await readKatmerFile(file, {
+      cwd: this.opts.cwd,
+      errorMessage: "Failed to run task file"
+    })
+    await using targetResolver = new KatmerTargetResolver(
+      this,
+      contents.targets
+    )
+    const defaultOpts = contents.defaults || {}
+    defaultOpts.targets = wrapInArray(defaultOpts.targets)
+
+    const fileContext = {}
+
+    for (const taskConfig of contents.tasks || []) {
+      const task = new KatmerTask(this, targetResolver, taskConfig)
+
+      await task.run(fileContext)
+    }
+  }
+  async [Symbol.asyncDispose]() {
+    return
+  }
+}
+
+export type { Katmer } from "./interfaces/task.interface"

package/lib/lookup/env.lookup.ts

@@ -0,0 +1,13 @@
+import { get } from "es-toolkit/compat"
+import type { Katmer } from "../interfaces/task.interface"
+
+export const EnvLookup = {
+  key: "env",
+  handler: async (
+    _ctx: Katmer.TaskContext,
+    envKeyParts: string[],
+    _opts: Record<string, any>
+  ) => {
+    return get(process.env, envKeyParts)
+  }
+}

package/lib/lookup/file.lookup.ts

@@ -0,0 +1,23 @@
+import type { Katmer } from "../interfaces/task.interface"
+import fs from "node:fs/promises"
+import path from "node:path"
+
+export const FileLookup = {
+  key: "file",
+  handler: async (
+    ctx: Katmer.TaskContext,
+    pathParts: string[],
+    options = {} as {
+      cwd?: string
+      encoding?: BufferEncoding
+    }
+  ) => {
+    return await fs.readFile(
+      path.resolve(options.cwd || ctx.config.cwd || "", ...pathParts),
+      {
+        encoding: "utf-8",
+        ...options
+      }
+    )
+  }
+}

package/lib/lookup/index.ts

@@ -0,0 +1,46 @@
+import { EnvLookup } from "./env.lookup"
+import { VarLookup } from "./var.lookup"
+import { URLLookup } from "./url.lookup"
+import { FileLookup } from "./file.lookup"
+import { isPlainObject } from "es-toolkit"
+import { cls } from "../utils/cls"
+
+export const Lookup = {
+  handlers: {
+    [EnvLookup.key]: EnvLookup,
+    [VarLookup.key]: VarLookup,
+    [URLLookup.key]: URLLookup,
+    [FileLookup.key]: FileLookup
+  },
+  async execute(store: string, ...args: any[]) {
+    if (!this.handlers[store]) {
+      throw new Error(`Unknown lookup store: ${store}`)
+    }
+
+    const lastArg = args.at(-1)
+    let keys: any[]
+    let opts = {} as Record<string, any>
+    if (isPlainObject(lastArg)) {
+      opts = lastArg
+      keys = args.slice(0, -1)
+    } else {
+      keys = args
+    }
+
+    const { default: defaultValue, error, ...options } = opts || {}
+    const ctx = cls.getStore()!
+    try {
+      return (
+        (await this.handlers[store].handler(ctx, keys, options)) ?? defaultValue
+      )
+    } catch (e: any) {
+      if (error === "ignore") {
+        return defaultValue
+      } else if (error === "warn") {
+        ctx.logger.warn(`Lookup to ${store} failed: ${e.message}`)
+      } else {
+        throw e
+      }
+    }
+  }
+}

package/lib/lookup/url.lookup.ts

@@ -0,0 +1,21 @@
+import { isPlainObject } from "es-toolkit"
+import type { Katmer } from "../interfaces/task.interface"
+
+export const URLLookup = {
+  key: "url",
+  handler: async (
+    _ctx: Katmer.TaskContext,
+    urlParts: string[],
+    options = {} as RequestInit
+  ) => {
+    const url = new URL(urlParts.join("/"))
+    const res = await fetch(url, options)
+    if (res.ok) {
+      return await res.text()
+    } else {
+      throw new Error(
+        `Failed to fetch url: ${url} status: ${res.status} response: ${(await res.text()) ?? "no response"}`
+      )
+    }
+  }
+}

package/lib/lookup/var.lookup.ts

@@ -0,0 +1,13 @@
+import { get } from "es-toolkit/compat"
+import type { Katmer } from "../interfaces/task.interface"
+
+export const VarLookup = {
+  key: "var",
+  handler: async (
+    ctx: Katmer.TaskContext,
+    varParts: string[],
+    _opts: Record<string, any>
+  ) => {
+    return get(ctx.variables, varParts)
+  }
+}