@ticatec/omniflow-core 0.1.1 → 0.2.0

package/src/primitives/shell.ts

@@ -0,0 +1,157 @@
+import path from 'node:path'
+import { execa, type Options as ExecaOptions } from 'execa'
+import { tryGetContext } from '../context/index.js'
+import { templateToArgv } from '../utils/template.js'
+import { maskString } from '../utils/mask.js'
+import {
+  resolveEnv,
+  getSecretValues,
+  runSubprocess,
+  createMaskTransform
+} from './subprocess.js'
+
+export { createMaskTransform }
+
+export interface RunOptions {
+  /** Working directory (defaults to context's active module or workspace) */
+  cwd?: string
+  /** Extra environment variables merged over process and context env */
+  env?: Record<string, string>
+  /** Reject promise on non-zero exit code (default: true) */
+  reject?: boolean
+  /** Capture and return stdout / stderr */
+  capture?: boolean
+}
+
+export interface ShellOutputResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+  failed?: boolean
+  signal?: string
+}
+
+function resolveCwd(explicitCwd?: string): string {
+  if (explicitCwd) return explicitCwd
+  const ctx = tryGetContext()
+  if (ctx) {
+    if (ctx.moduleFolder) {
+      return path.resolve(ctx.workspace, ctx.moduleFolder)
+    }
+    if (ctx.workspace) {
+      return ctx.workspace
+    }
+  }
+  return process.cwd()
+}
+
+/**
+ * Execute command via execa, piping output and handling dryRun.
+ */
+async function executeInternal(
+  fileOrCmd: string,
+  args: string[] | undefined,
+  options: RunOptions & { isShell?: boolean }
+): Promise<ShellOutputResult> {
+  const ctx = tryGetContext()
+  const cwd = resolveCwd(options.cwd)
+  const env = resolveEnv(options.env)
+  const secrets = getSecretValues()
+  const cmdDisplay = args ? [fileOrCmd, ...args].join(' ') : fileOrCmd
+  const maskedCmd = maskString(cmdDisplay, secrets)
+
+  // Dry-run interception
+  if (ctx?.dryRun) {
+    ctx.logger.info(`[DRY-RUN] Executing: ${maskedCmd} (cwd: ${cwd})`)
+    return {
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+      failed: false
+    }
+  }
+
+  const execaOpts: ExecaOptions = {
+    cwd,
+    env,
+    reject: options.reject ?? true,
+    shell: options.isShell ?? false
+  }
+
+  const displayCmd = `$ ${maskedCmd}`
+  ctx?.logger?.info?.(displayCmd)
+
+  const subprocess = args
+    ? execa(fileOrCmd, args, execaOpts)
+    : execa(fileOrCmd, execaOpts)
+
+  return runSubprocess({
+    subprocess,
+    displayCmd,
+    cmdText: maskedCmd,
+    errorPrefix: 'Command',
+    reject: options.reject ?? true,
+    secrets
+  })
+}
+
+/**
+ * Tagged template runner signature.
+ */
+export interface TemplateRunner {
+  (template: TemplateStringsArray, ...values: unknown[]): Promise<ShellOutputResult>
+}
+
+/**
+ * `shell.run` runner function supporting:
+ * 1. `shell.run`docker build -t ${img} .``
+ * 2. `shell.run({ cwd: '/app' })`docker build -t ${img} .``
+ */
+export function run(options: RunOptions): TemplateRunner
+export function run(template: TemplateStringsArray, ...values: unknown[]): Promise<ShellOutputResult>
+export function run(
+  templateOrOptions: TemplateStringsArray | RunOptions,
+  ...values: unknown[]
+): Promise<ShellOutputResult> | TemplateRunner {
+  // Overload 2: options passed first, returns a TemplateRunner
+  if (!Array.isArray(templateOrOptions) || !('raw' in templateOrOptions)) {
+    const options = (templateOrOptions as RunOptions) ?? {}
+    return async (template: TemplateStringsArray, ...innerValues: unknown[]) => {
+      const argv = templateToArgv(template, innerValues)
+      if (argv.length === 0) {
+        throw new Error('Command is empty')
+      }
+      const [cmd, ...args] = argv
+      return executeInternal(cmd, args, options)
+    }
+  }
+
+  // Overload 1: direct tagged template
+  const template = templateOrOptions as TemplateStringsArray
+  const argv = templateToArgv(template, values)
+  if (argv.length === 0) {
+    throw new Error('Command is empty')
+  }
+  const [cmd, ...args] = argv
+  return executeInternal(cmd, args, {})
+}
+
+/**
+ * Run a command string via the shell (supports pipes, redirects, &&, ||).
+ */
+export async function sh(cmd: string, options: RunOptions = {}): Promise<ShellOutputResult> {
+  return executeInternal(cmd, undefined, { ...options, isShell: true })
+}
+
+/**
+ * Run a command and capture its stdout, stderr and exitCode without throwing on failure.
+ */
+export async function output(cmd: string, options: RunOptions = {}): Promise<ShellOutputResult> {
+  return executeInternal(cmd, undefined, { ...options, isShell: true, reject: false, capture: true })
+}
+
+export const shell = {
+  run,
+  sh,
+  output
+}

package/src/primitives/ssh.ts

@@ -0,0 +1,249 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import { tmpdir } from 'node:os'
+import { execa } from 'execa'
+import { tryGetContext } from '../context/index.js'
+import { maskString } from '../utils/mask.js'
+import {
+  getSecretValues,
+  resolveEnv,
+  runSubprocess
+} from './subprocess.js'
+
+export interface SshServerConfig {
+  host?: string
+  server?: string
+  user: string
+  privateKeyFile?: string
+  privateKey?: string
+  port?: number
+  tty?: boolean
+  connectTimeout?: number
+}
+
+export interface SshAuthConfig {
+  user: string
+  privateKey?: string
+  privateKeyFile?: string
+}
+
+export interface SshConnectionConfig extends SshAuthConfig {
+  host: string
+  port?: number
+  tty?: boolean
+  connectTimeout?: number
+}
+
+export type SshTarget = string | SshConnectionConfig
+
+export interface SshResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+  failed?: boolean
+  signal?: string
+}
+
+function resolveTarget(
+  target: SshTarget,
+  configMap: Record<string, SshServerConfig> = {}
+): SshConnectionConfig {
+  if (typeof target !== 'string') {
+    if (!target.host || !target.user) {
+      throw new Error('SSH target config requires both "host" and "user"')
+    }
+    return target
+  }
+
+  const config = configMap[target]
+  if (!config) {
+    const known = Object.keys(configMap)
+    throw new Error(
+      `SSH target configuration not found for key: "${target}". ` +
+      (known.length ? `Configured targets: ${known.join(', ')}` : 'No SSH targets configured.')
+    )
+  }
+
+  const host = config.host || config.server
+  if (!host) {
+    throw new Error(`SSH config '${target}' is missing host/server address`)
+  }
+
+  return {
+    host,
+    user: config.user,
+    privateKeyFile: config.privateKeyFile,
+    privateKey: config.privateKey,
+    port: config.port,
+    connectTimeout: config.connectTimeout,
+    tty: config.tty
+  }
+}
+
+async function createTempKeyFile(keyContent: string): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(tmpdir(), 'omniflow-ssh-'))
+  const keyFile = path.join(dir, 'id_rsa')
+  await fs.writeFile(keyFile, keyContent, { mode: 0o600 })
+  return keyFile
+}
+
+function connectionArgs(
+  config: SshConnectionConfig,
+  keyFile: string | undefined,
+  portFlag: '-p' | '-P'
+): string[] {
+  const args = [
+    '-o', 'BatchMode=yes',
+    '-o', 'StrictHostKeyChecking=accept-new',
+    '-o', `ConnectTimeout=${config.connectTimeout ?? 15}`,
+    portFlag, String(config.port ?? 22)
+  ]
+  if (keyFile) {
+    args.push('-i', keyFile)
+  }
+  return args
+}
+
+function shellQuote(str: string): string {
+  if (/^[a-zA-Z0-9_./-]+$/.test(str)) return str
+  return `'${str.replace(/'/g, "'\\''")}'`
+}
+
+export class SshClient {
+  private readonly configMap: Record<string, SshServerConfig>
+
+  constructor(configMap: Record<string, SshServerConfig> = {}) {
+    this.configMap = configMap
+  }
+
+  async exec(
+    target: SshTarget,
+    remoteCommand: string,
+    remoteDir?: string
+  ): Promise<SshResult> {
+    const ctx = tryGetContext()
+    const config = resolveTarget(target, this.configMap)
+    const secrets = getSecretValues()
+    const maskedCmd = maskString(remoteCommand, secrets)
+
+    if (ctx?.dryRun) {
+      ctx.logger.info(`[DRY-RUN] SSH to ${config.user}@${config.host}: ${maskedCmd} (remoteDir: ${remoteDir ?? '~'})`)
+      return { stdout: '', stderr: '', exitCode: 0, failed: false }
+    }
+
+    let tempKeyFile: string | undefined
+    try {
+      if (config.privateKey) {
+        tempKeyFile = await createTempKeyFile(config.privateKey)
+      }
+
+      const keyFile = tempKeyFile || config.privateKeyFile
+      const args = connectionArgs(config, keyFile, '-p')
+
+      if (config.tty) {
+        args.push('-tt')
+      }
+
+      args.push(`${config.user}@${config.host}`)
+
+      const script = remoteDir
+        ? `cd ${shellQuote(remoteDir)} || exit 1\n${remoteCommand}`
+        : remoteCommand
+
+      args.push(script)
+
+      const displayCmd = `SSH (${config.user}@${config.host}) $ ${maskedCmd}`
+      ctx?.logger?.info?.(displayCmd)
+
+      const subprocess = execa('ssh', args, { reject: true, env: resolveEnv() })
+
+      return await runSubprocess({
+        subprocess,
+        displayCmd,
+        cmdText: maskedCmd,
+        errorPrefix: 'SSH command',
+        reject: true,
+        secrets
+      })
+    } finally {
+      if (tempKeyFile) {
+        await fs.rm(path.dirname(tempKeyFile), { recursive: true, force: true }).catch(() => {})
+      }
+    }
+  }
+
+  async cp(
+    target: SshTarget,
+    srcFile: string,
+    targetFolder: string
+  ): Promise<void> {
+    const ctx = tryGetContext()
+    const config = resolveTarget(target, this.configMap)
+    const secrets = getSecretValues()
+
+    if (ctx?.dryRun) {
+      ctx.logger.info(`[DRY-RUN] SCP: Copy ${srcFile} -> ${config.user}@${config.host}:${targetFolder}`)
+      return
+    }
+
+    let tempKeyFile: string | undefined
+    try {
+      if (config.privateKey) {
+        tempKeyFile = await createTempKeyFile(config.privateKey)
+      }
+
+      const keyFile = tempKeyFile || config.privateKeyFile
+      const args = connectionArgs(config, keyFile, '-P')
+
+      args.push(srcFile)
+      args.push(`${config.user}@${config.host}:${targetFolder}`)
+
+      const displayCmd = `SCP ${srcFile} -> ${config.user}@${config.host}:${targetFolder}`
+      ctx?.logger?.info?.(displayCmd)
+
+      const subprocess = execa('scp', args, { reject: true, env: resolveEnv() })
+
+      await runSubprocess({
+        subprocess,
+        displayCmd,
+        cmdText: displayCmd,
+        errorPrefix: 'SCP',
+        reject: true,
+        secrets
+      })
+    } finally {
+      if (tempKeyFile) {
+        await fs.rm(path.dirname(tempKeyFile), { recursive: true, force: true }).catch(() => {})
+      }
+    }
+  }
+}
+
+/** Default singleton instance helper */
+const defaultClientConfigMap: Record<string, SshServerConfig> = {}
+const defaultClient = new SshClient(defaultClientConfigMap)
+
+export const ssh = {
+  exec: (target: SshTarget, command: string, remoteDir?: string) =>
+    defaultClient.exec(target, command, remoteDir),
+  cp: (target: SshTarget, srcFile: string, targetFolder: string) =>
+    defaultClient.cp(target, srcFile, targetFolder),
+  createClient: (configMap: Record<string, SshServerConfig>) =>
+    new SshClient(configMap),
+  configure: (
+    nameOrMap: string | Record<string, SshServerConfig>,
+    config?: SshServerConfig
+  ) => {
+    if (typeof nameOrMap === 'string' && config) {
+      defaultClientConfigMap[nameOrMap] = config
+    } else if (typeof nameOrMap === 'object' && nameOrMap !== null) {
+      Object.assign(defaultClientConfigMap, nameOrMap)
+    }
+  },
+  /** Reset/clear all configured SSH targets on the singleton instance */
+  reset: () => {
+    for (const key of Object.keys(defaultClientConfigMap)) {
+      delete defaultClientConfigMap[key]
+    }
+  }
+}