kodu 1.1.21 → 2.0.0

package/src/commands/ops/ops.utils.ts

@@ -1,160 +0,0 @@
-import { access } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import type { KoduConfig, ServerConfig } from '../../core/config/config.schema';
-import type { SshResult } from '../../shared/ssh/ssh.service';
-import {
-  OpsCliError,
-  type OpsErrorCode,
-  type ResolvedServerConfig,
-} from './ops.types';
-
-const DEFAULT_APPS_PATH = '/var/agent-apps';
-
-export function printJson(payload: unknown, isError = false): void {
-  const line = JSON.stringify(payload);
-  if (isError) {
-    console.error(line);
-    return;
-  }
-  console.log(line);
-}
-
-export function printCliError(error: unknown): void {
-  const cliError = toCliError(error);
-  printJson(
-    {
-      status: 'error',
-      code: cliError.code,
-      error: cliError.message,
-    },
-    true,
-  );
-}
-
-export function printSshError(result: SshResult, command: string): void {
-  printJson({
-    status: 'error',
-    code: result.exitCode,
-    stderr: result.stderr || result.error || 'Unknown SSH error',
-    command,
-  });
-}
-
-export async function resolveServerOrThrow(
-  config: KoduConfig,
-  alias: string,
-): Promise<ResolvedServerConfig> {
-  const servers = config.ops?.servers;
-  if (!servers) {
-    throw new OpsCliError(
-      'CONFIG_ERROR',
-      'ops.servers not configured in kodu.json',
-    );
-  }
-
-  const server = servers[alias];
-  if (!server) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `Server alias '${alias}' not found in kodu.json`,
-    );
-  }
-
-  const resolved = normalizeServer(server);
-  await assertSshKeyExists(resolved.sshKeyPath);
-  return resolved;
-}
-
-export function resolveAppsPath(server: ResolvedServerConfig): string {
-  return server.paths?.apps ?? DEFAULT_APPS_PATH;
-}
-
-export function resolveCaddyPath(server: ResolvedServerConfig): string {
-  return (
-    server.paths?.caddy ?? path.posix.join(resolveAppsPath(server), 'caddy')
-  );
-}
-
-export function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-
-export function ensureEnvKey(key: string | undefined): string {
-  if (!key) {
-    throw new OpsCliError('VALIDATION_ERROR', 'Option --key is required');
-  }
-
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      'Invalid env key format. Allowed: [A-Za-z_][A-Za-z0-9_]*',
-    );
-  }
-
-  return key;
-}
-
-export function ensureRequired(
-  value: string | undefined,
-  name: string,
-): string {
-  if (!value) {
-    throw new OpsCliError('VALIDATION_ERROR', `Option --${name} is required`);
-  }
-  return value;
-}
-
-export function ensureAction<T extends string>(
-  value: string,
-  allowed: readonly T[],
-  context: string,
-): T {
-  if (!allowed.includes(value as T)) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `Unsupported ${context}: '${value}'. Allowed: ${allowed.join(', ')}`,
-    );
-  }
-  return value as T;
-}
-
-function normalizeServer(server: ServerConfig): ResolvedServerConfig {
-  const sshKeyPath = server.sshKeyPath.startsWith('~')
-    ? path.join(os.homedir(), server.sshKeyPath.slice(1))
-    : server.sshKeyPath;
-  const apps = server.paths?.apps ?? DEFAULT_APPS_PATH;
-  return {
-    ...server,
-    sshKeyPath: path.isAbsolute(sshKeyPath)
-      ? sshKeyPath
-      : path.resolve(process.cwd(), sshKeyPath),
-    paths: {
-      apps,
-      caddy: server.paths?.caddy,
-    },
-  };
-}
-
-async function assertSshKeyExists(sshKeyPath: string): Promise<void> {
-  try {
-    await access(sshKeyPath);
-  } catch {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `SSH key file not found or inaccessible: ${sshKeyPath}`,
-    );
-  }
-}
-
-function toCliError(error: unknown): { code: OpsErrorCode; message: string } {
-  if (error instanceof OpsCliError) {
-    return { code: error.code, message: error.message };
-  }
-
-  if (error instanceof Error) {
-    return { code: 'CLI_ERROR', message: error.message };
-  }
-
-  return { code: 'CLI_ERROR', message: 'Unknown CLI error' };
-}

package/src/commands/ops/subcommands/ops-env.command.ts

@@ -1,165 +0,0 @@
-import path from 'node:path';
-import { CommandRunner, Option, SubCommand } from 'nest-commander';
-import { ConfigService } from '../../../core/config/config.service';
-import { SshService } from '../../../shared/ssh/ssh.service';
-import { OpsCliError } from '../ops.types';
-import {
-  ensureAction,
-  ensureEnvKey,
-  ensureRequired,
-  printCliError,
-  printJson,
-  printSshError,
-  resolveAppsPath,
-  resolveServerOrThrow,
-  shellQuote,
-} from '../ops.utils';
-
-type OpsEnvAction = 'get' | 'set' | 'unset';
-
-type OpsEnvOptions = {
-  server?: string;
-  action?: string;
-  project?: string;
-  key?: string;
-  val?: string;
-};
-
-@SubCommand({
-  name: 'env',
-  description:
-    'Manage remote .env files for a specific project.\nExamples:\n  kodu ops env --server dev --action get --project my-app\n  kodu ops env --server dev --action set --project my-app --key PORT --val 3000\n  kodu ops env --server dev --action unset --project my-app --key PORT',
-})
-export class OpsEnvCommand extends CommandRunner {
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly sshService: SshService,
-  ) {
-    super();
-  }
-
-  @Option({
-    flags: '-s, --server <name>',
-    description: 'Server alias defined in kodu.json (e.g., dev)',
-  })
-  parseServer(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-a, --action <type>',
-    description: 'Action to perform: get | set | unset',
-  })
-  parseAction(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-p, --project <name>',
-    description: 'Target project directory name',
-  })
-  parseProject(value: string): string {
-    return value;
-  }
-
-  @Option({ flags: '--key <key>', description: 'Environment key' })
-  parseKey(value: string): string {
-    return value;
-  }
-
-  @Option({ flags: '--val <value>', description: 'Environment value' })
-  parseVal(value: string): string {
-    return value;
-  }
-
-  async run(
-    passedParams: string[],
-    options: OpsEnvOptions = {},
-  ): Promise<void> {
-    try {
-      if (passedParams.length > 0) {
-        throw new OpsCliError(
-          'VALIDATION_ERROR',
-          'Positional arguments are not supported. Use named flags (e.g., --server, --action). Run with --help for examples.',
-        );
-      }
-
-      const serverAlias = ensureRequired(options.server, 'server');
-      const rawAction = ensureRequired(options.action, 'action');
-      const project = ensureRequired(options.project, 'project');
-
-      const action = ensureAction<OpsEnvAction>(
-        rawAction,
-        ['get', 'set', 'unset'],
-        'env action',
-      );
-      const server = await resolveServerOrThrow(
-        this.configService.getConfig(),
-        serverAlias,
-      );
-      const envPath = path.posix.join(resolveAppsPath(server), project, '.env');
-
-      const command = this.buildCommand(action, envPath, options);
-      const result = await this.sshService.execute(server, command);
-
-      if (!result.success) {
-        printSshError(result, command);
-        return;
-      }
-
-      if (action === 'get') {
-        printJson({ status: 'ok', data: { content: result.stdout } });
-        return;
-      }
-
-      printJson({ status: 'ok', message: 'Env updated' });
-    } catch (error) {
-      printCliError(error);
-      process.exitCode = 1;
-    }
-  }
-
-  private buildCommand(
-    action: OpsEnvAction,
-    envPath: string,
-    options: OpsEnvOptions,
-  ): string {
-    const quotedPath = shellQuote(envPath);
-
-    if (action === 'get') {
-      return `cat ${quotedPath}`;
-    }
-
-    const key = ensureEnvKey(options.key);
-    const quotedKey = shellQuote(key);
-
-    if (action === 'set') {
-      const val = ensureRequired(options.val, 'val');
-      const quotedVal = shellQuote(val);
-      const scriptLines = [
-        `ENV_FILE=${quotedPath}`,
-        `KEY=${quotedKey}`,
-        `VAL=${quotedVal}`,
-        'mkdir -p "$(dirname "$ENV_FILE")"',
-        'touch "$ENV_FILE"',
-        'awk -v k="$KEY" -v v="$VAL" \'BEGIN{found=0} $0 ~ "^" k "=" { print k "=" v; found=1; next } { print } END { if (!found) print k "=" v }\' "$ENV_FILE" > "$ENV_FILE.tmp"',
-        'mv "$ENV_FILE.tmp" "$ENV_FILE"',
-      ];
-      return this.buildBashScript(scriptLines);
-    }
-
-    const scriptLines = [
-      `ENV_FILE=${quotedPath}`,
-      `KEY=${quotedKey}`,
-      'if [ ! -f "$ENV_FILE" ]; then exit 0; fi',
-      'grep -v "^$KEY=" "$ENV_FILE" > "$ENV_FILE.tmp"',
-      'mv "$ENV_FILE.tmp" "$ENV_FILE"',
-    ];
-    return this.buildBashScript(scriptLines);
-  }
-
-  private buildBashScript(scriptLines: string[]): string {
-    const script = scriptLines.join(' && ');
-    return `bash -lc ${shellQuote(script)}`;
-  }
-}

package/src/commands/ops/subcommands/ops-routes.command.ts

@@ -1,221 +0,0 @@
-import path from 'node:path';
-import { CommandRunner, Option, SubCommand } from 'nest-commander';
-import { ConfigService } from '../../../core/config/config.service';
-import { SshService } from '../../../shared/ssh/ssh.service';
-import { OpsCliError } from '../ops.types';
-import {
-  ensureAction,
-  ensureRequired,
-  printCliError,
-  printJson,
-  printSshError,
-  resolveCaddyPath,
-  resolveServerOrThrow,
-  shellQuote,
-} from '../ops.utils';
-
-type OpsRoutesAction = 'list' | 'add' | 'remove' | 'update';
-
-type OpsRoutesOptions = {
-  server?: string;
-  action?: string;
-  domain?: string;
-  upstream?: string;
-};
-
-@SubCommand({
-  name: 'routes',
-  description:
-    'Manage remote Caddy reverse proxy routes.\nExamples:\n  kodu ops routes --server dev --action list\n  kodu ops routes --server dev --action add --domain api.example.com --upstream 127.0.0.1:3000\n  kodu ops routes --server dev --action update --domain api.example.com --upstream 127.0.0.1:4000\n  kodu ops routes --server dev --action remove --domain api.example.com',
-})
-export class OpsRoutesCommand extends CommandRunner {
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly sshService: SshService,
-  ) {
-    super();
-  }
-
-  @Option({
-    flags: '-s, --server <name>',
-    description: 'Server alias defined in kodu.json (e.g., dev)',
-  })
-  parseServer(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-a, --action <type>',
-    description: 'Action to perform: list | add | remove | update',
-  })
-  parseAction(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '--domain <domain>',
-    description: 'Domain name (required for add, update, remove)',
-  })
-  parseDomain(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '--upstream <upstream>',
-    description: 'Upstream host:port (required for add, update)',
-  })
-  parseUpstream(value: string): string {
-    return value;
-  }
-
-  async run(
-    passedParams: string[],
-    options: OpsRoutesOptions = {},
-  ): Promise<void> {
-    try {
-      if (passedParams.length > 0) {
-        throw new OpsCliError(
-          'VALIDATION_ERROR',
-          'Positional arguments are not supported. Use named flags (e.g., --server, --action). Run with --help for examples.',
-        );
-      }
-
-      const serverAlias = ensureRequired(options.server, 'server');
-      const rawAction = ensureRequired(options.action, 'action');
-      const action = ensureAction<OpsRoutesAction>(
-        rawAction,
-        ['list', 'add', 'remove', 'update'],
-        'routes action',
-      );
-      const server = await resolveServerOrThrow(
-        this.configService.getConfig(),
-        serverAlias,
-      );
-
-      const caddyRoot = resolveCaddyPath(server);
-      const caddyfilePath = path.posix.join(caddyRoot, 'data', 'Caddyfile');
-
-      if (action === 'list') {
-        const command = `cat ${shellQuote(caddyfilePath)}`;
-        const result = await this.sshService.execute(server, command);
-        if (!result.success) {
-          printSshError(result, command);
-          return;
-        }
-
-        printJson({ status: 'ok', data: { caddyfile: result.stdout } });
-        return;
-      }
-
-      const domain = ensureRequired(options.domain, 'domain');
-      const upstream =
-        action === 'add' || action === 'update'
-          ? ensureRequired(options.upstream, 'upstream')
-          : '';
-
-      const editCommand = this.buildEditCommand({
-        action,
-        caddyfilePath,
-        domain,
-        upstream,
-      });
-      const editResult = await this.sshService.execute(server, editCommand);
-
-      if (!editResult.success) {
-        if (editResult.exitCode === 4) {
-          printJson({
-            status: 'error',
-            code: 'NOT_FOUND',
-            stderr: editResult.stderr || editResult.stdout || 'Route not found',
-            command: editCommand,
-          });
-          return;
-        }
-
-        printSshError(editResult, editCommand);
-        return;
-      }
-
-      const applyCommand = `cd ${shellQuote(caddyRoot)} && ./caddy.sh`;
-      const applyResult = await this.sshService.execute(server, applyCommand);
-      if (!applyResult.success) {
-        printSshError(applyResult, applyCommand);
-        return;
-      }
-
-      printJson({
-        status: 'ok',
-        message: 'Routes updated',
-        data: {
-          action,
-          domain,
-          upstream: upstream || undefined,
-          caddyOutput: applyResult.stdout,
-        },
-      });
-    } catch (error) {
-      printCliError(error);
-      process.exitCode = 1;
-    }
-  }
-
-  private buildEditCommand(params: {
-    action: Exclude<OpsRoutesAction, 'list'>;
-    caddyfilePath: string;
-    domain: string;
-    upstream: string;
-  }): string {
-    const script = this.buildPythonScript(params);
-    return `python3 -c ${shellQuote(script)}`;
-  }
-
-  private buildPythonScript(params: {
-    action: Exclude<OpsRoutesAction, 'list'>;
-    caddyfilePath: string;
-    domain: string;
-    upstream: string;
-  }): string {
-    return [
-      'import json',
-      'import os',
-      'import random',
-      'import re',
-      'import sys',
-      'import time',
-      'from pathlib import Path',
-      `file_path = ${JSON.stringify(params.caddyfilePath)}`,
-      `action = ${JSON.stringify(params.action)}`,
-      `domain = ${JSON.stringify(params.domain)}`,
-      `upstream = ${JSON.stringify(params.upstream)}`,
-      'with Path(file_path).open("r", encoding="utf-8") as handle:',
-      '  text = handle.read()',
-      'domain_re = re.compile(r"(^|\\n)\\s*" + re.escape(domain) + r"\\s*\\{[\\s\\S]*?\\n\\}", re.MULTILINE)',
-      'if action == "add":',
-      '  if domain_re.search(text):',
-      '    sys.stderr.write("Route already exists for domain")',
-      '    sys.exit(3)',
-      '  block = "\\n" + domain + " {\\n  reverse_proxy " + upstream + "\\n}\\n"',
-      '  text = re.sub(r"\\s*$", "", text) + block',
-      'elif action == "remove":',
-      '  if not domain_re.search(text):',
-      '    sys.stderr.write("Route not found")',
-      '    sys.exit(4)',
-      '  text = domain_re.sub("\\n", text, count=1)',
-      '  text = re.sub(r"\\n{3,}", "\\n\\n", text)',
-      '  text = re.sub(r"^\\n+", "", text)',
-      'elif action == "update":',
-      '  match = domain_re.search(text)',
-      '  if not match:',
-      '    sys.stderr.write("Route not found")',
-      '    sys.exit(4)',
-      '  block = match.group(0)',
-      '  updated = re.sub(r"reverse_proxy\\s+[^\\n]+", "reverse_proxy " + upstream, block, count=1)',
-      '  text = domain_re.sub(updated, text, count=1)',
-      'tmp = os.path.join(os.path.dirname(file_path), ".tmp-" + str(int(time.time() * 1000)) + "-" + format(random.getrandbits(48), "x"))',
-      'with open(tmp, "w", encoding="utf-8") as handle:',
-      '  handle.write(text)',
-      'os.replace(tmp, file_path)',
-      'print(json.dumps({"status": "ok"}))',
-    ].join('\n');
-  }
-}