kodu 1.1.13 → 1.1.15

package/src/commands/ops/ops.command.ts

@@ -0,0 +1,30 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { printJson } from './ops.utils';
+import { OpsEnvCommand } from './subcommands/ops-env.command';
+import { OpsRoutesCommand } from './subcommands/ops-routes.command';
+import { OpsServiceCommand } from './subcommands/ops-service.command';
+import { OpsSysinfoCommand } from './subcommands/ops-sysinfo.command';
+
+@Command({
+  name: 'ops',
+  description: 'Remote server operations for agents',
+  subCommands: [
+    OpsSysinfoCommand,
+    OpsEnvCommand,
+    OpsRoutesCommand,
+    OpsServiceCommand,
+  ],
+})
+export class OpsCommand extends CommandRunner {
+  async run(): Promise<void> {
+    printJson(
+      {
+        status: 'error',
+        code: 'VALIDATION_ERROR',
+        error: 'Missing ops subcommand',
+      },
+      true,
+    );
+    process.exitCode = 1;
+  }
+}

package/src/commands/ops/ops.module.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '../../core/config/config.module';
+import { SshModule } from '../../shared/ssh/ssh.module';
+import { OpsCommand } from './ops.command';
+import { OpsEnvCommand } from './subcommands/ops-env.command';
+import { OpsRoutesCommand } from './subcommands/ops-routes.command';
+import { OpsServiceCommand } from './subcommands/ops-service.command';
+import { OpsSysinfoCommand } from './subcommands/ops-sysinfo.command';
+
+@Module({
+  imports: [ConfigModule, SshModule],
+  providers: [
+    OpsCommand,
+    OpsSysinfoCommand,
+    OpsEnvCommand,
+    OpsRoutesCommand,
+    OpsServiceCommand,
+  ],
+})
+export class OpsModule {}

package/src/commands/ops/ops.types.ts

@@ -0,0 +1,24 @@
+import type { ServerConfig } from '../../core/config/config.schema';
+
+export type OpsErrorCode =
+  | 'CLI_ERROR'
+  | 'CONFIG_ERROR'
+  | 'NOT_FOUND'
+  | 'VALIDATION_ERROR';
+
+export type ResolvedServerConfig = ServerConfig & {
+  sshKeyPath: string;
+  paths?: {
+    apps: string;
+    caddy?: string;
+  };
+};
+
+export class OpsCliError extends Error {
+  constructor(
+    public readonly code: OpsErrorCode,
+    message: string,
+  ) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,156 @@
+import { access } from 'node:fs/promises';
+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 apps = server.paths?.apps ?? DEFAULT_APPS_PATH;
+  return {
+    ...server,
+    sshKeyPath: path.isAbsolute(server.sshKeyPath)
+      ? server.sshKeyPath
+      : path.resolve(process.cwd(), server.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

@@ -0,0 +1,121 @@
+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 {
+  ensureAction,
+  ensureEnvKey,
+  ensureRequired,
+  printCliError,
+  printJson,
+  printSshError,
+  resolveAppsPath,
+  resolveServerOrThrow,
+  shellQuote,
+} from '../ops.utils';
+
+type OpsEnvAction = 'get' | 'set' | 'unset';
+
+type OpsEnvOptions = {
+  key?: string;
+  val?: string;
+};
+
+@SubCommand({
+  name: 'env',
+  description: 'Manage remote .env files',
+  arguments: '<alias> <action> <project>',
+})
+export class OpsEnvCommand extends CommandRunner {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly sshService: SshService,
+  ) {
+    super();
+  }
+
+  @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> {
+    const [alias, rawAction, project] = passedParams;
+
+    try {
+      const action = ensureAction<OpsEnvAction>(
+        rawAction,
+        ['get', 'set', 'unset'],
+        'env action',
+      );
+      const server = await resolveServerOrThrow(
+        this.configService.getConfig(),
+        alias,
+      );
+      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);
+      return [
+        `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"',
+      ].join(' && ');
+    }
+
+    return [
+      `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"',
+    ].join(' && ');
+  }
+}

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

@@ -0,0 +1,185 @@
+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 {
+  ensureAction,
+  ensureRequired,
+  printCliError,
+  printJson,
+  printSshError,
+  resolveCaddyPath,
+  resolveServerOrThrow,
+  shellQuote,
+} from '../ops.utils';
+
+type OpsRoutesAction = 'list' | 'add' | 'remove' | 'update';
+
+type OpsRoutesOptions = {
+  domain?: string;
+  upstream?: string;
+};
+
+@SubCommand({
+  name: 'routes',
+  description: 'Manage remote Caddy routes',
+  arguments: '<alias> <action>',
+})
+export class OpsRoutesCommand extends CommandRunner {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly sshService: SshService,
+  ) {
+    super();
+  }
+
+  @Option({ flags: '--domain <domain>', description: 'Domain name' })
+  parseDomain(value: string): string {
+    return value;
+  }
+
+  @Option({ flags: '--upstream <upstream>', description: 'Upstream host:port' })
+  parseUpstream(value: string): string {
+    return value;
+  }
+
+  async run(
+    passedParams: string[],
+    options: OpsRoutesOptions = {},
+  ): Promise<void> {
+    const [alias, rawAction] = passedParams;
+
+    try {
+      const action = ensureAction<OpsRoutesAction>(
+        rawAction,
+        ['list', 'add', 'remove', 'update'],
+        'routes action',
+      );
+      const server = await resolveServerOrThrow(
+        this.configService.getConfig(),
+        alias,
+      );
+      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.buildNodeScript(params);
+    return `node -e ${shellQuote(script)}`;
+  }
+
+  private buildNodeScript(params: {
+    action: Exclude<OpsRoutesAction, 'list'>;
+    caddyfilePath: string;
+    domain: string;
+    upstream: string;
+  }): string {
+    return [
+      "const fs = require('node:fs');",
+      "const p = require('node:path');",
+      `const filePath = ${JSON.stringify(params.caddyfilePath)};`,
+      `const action = ${JSON.stringify(params.action)};`,
+      `const domain = ${JSON.stringify(params.domain)};`,
+      `const upstream = ${JSON.stringify(params.upstream)};`,
+      "const esc = (s) => s.replace(/[.*+?^\\$\\{\\}()|[\\]\\\\]/g, '\\\\$&');",
+      "const read = fs.readFileSync(filePath, 'utf8');",
+      "const domainRe = new RegExp('(^|\\n)\\\\s*' + esc(domain) + '\\s*\\\\{[\\\\s\\\\S]*?\\\\n\\\\}', 'm');",
+      'let text = read;',
+      "if (action === 'add') {",
+      '  if (domainRe.test(text)) {',
+      "    process.stderr.write('Route already exists for domain');",
+      '    process.exit(3);',
+      '  }',
+      "  const block = '\\n' + domain + ' {\\n  reverse_proxy ' + upstream + '\\n}\\n';",
+      '  text = text.replace(/\\s*$/g, "") + block;',
+      "} else if (action === 'remove') {",
+      '  if (!domainRe.test(text)) {',
+      "    process.stderr.write('Route not found');",
+      '    process.exit(4);',
+      '  }',
+      "  text = text.replace(domainRe, '\\n').replace(/\\n{3,}/g, '\\n\\n').replace(/^\\n+/, '');",
+      "} else if (action === 'update') {",
+      '  const match = text.match(domainRe);',
+      '  if (!match) {',
+      "    process.stderr.write('Route not found');",
+      '    process.exit(4);',
+      '  }',
+      '  const block = match[0];',
+      "  const updated = block.replace(/reverse_proxy\\s+[^\\n]+/, 'reverse_proxy ' + upstream);",
+      '  text = text.replace(domainRe, updated);',
+      '}',
+      "const tmp = p.join(p.dirname(filePath), '.tmp-' + Date.now() + '-' + Math.random().toString(36).slice(2));",
+      "fs.writeFileSync(tmp, text, 'utf8');",
+      'fs.renameSync(tmp, filePath);',
+      "process.stdout.write(JSON.stringify({ status: 'ok' }));",
+    ].join('\n');
+  }
+}

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

@@ -0,0 +1,154 @@
+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 type { ResolvedServerConfig } from '../ops.types';
+import {
+  ensureAction,
+  ensureRequired,
+  printCliError,
+  printJson,
+  printSshError,
+  resolveAppsPath,
+  resolveServerOrThrow,
+  shellQuote,
+} from '../ops.utils';
+
+type OpsServiceAction = 'clone' | 'pull' | 'up' | 'down' | 'logs' | 'status';
+
+type OpsServiceOptions = {
+  repo?: string;
+};
+
+@SubCommand({
+  name: 'service',
+  description: 'Manage project lifecycle using Docker Compose',
+  arguments: '<alias> <action> <project>',
+})
+export class OpsServiceCommand extends CommandRunner {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly sshService: SshService,
+  ) {
+    super();
+  }
+
+  @Option({ flags: '--repo <url>', description: 'Repository URL for clone' })
+  parseRepo(value: string): string {
+    return value;
+  }
+
+  async run(
+    passedParams: string[],
+    options: OpsServiceOptions = {},
+  ): Promise<void> {
+    const [alias, rawAction, project] = passedParams;
+
+    try {
+      const action = ensureAction<OpsServiceAction>(
+        rawAction,
+        ['clone', 'pull', 'up', 'down', 'logs', 'status'],
+        'service action',
+      );
+      const server = await resolveServerOrThrow(
+        this.configService.getConfig(),
+        alias,
+      );
+      const projectPath = path.posix.join(resolveAppsPath(server), project);
+
+      if (action === 'status') {
+        await this.runStatus(server, projectPath);
+        return;
+      }
+
+      const command = this.buildActionCommand(action, projectPath, options);
+      const result = await this.sshService.execute(server, command);
+      if (!result.success) {
+        printSshError(result, command);
+        return;
+      }
+
+      printJson({
+        status: 'ok',
+        data: {
+          action,
+          project,
+          stdout: result.stdout,
+        },
+      });
+    } catch (error) {
+      printCliError(error);
+      process.exitCode = 1;
+    }
+  }
+
+  private buildActionCommand(
+    action: Exclude<OpsServiceAction, 'status'>,
+    projectPath: string,
+    options: OpsServiceOptions,
+  ): string {
+    const quotedProjectPath = shellQuote(projectPath);
+
+    if (action === 'clone') {
+      const repo = ensureRequired(options.repo, 'repo');
+      const quotedRepo = shellQuote(repo);
+      return [
+        `if [ -d ${quotedProjectPath} ]; then echo 'Project already exists' >&2; exit 3; fi`,
+        `git clone ${quotedRepo} ${quotedProjectPath}`,
+      ].join(' && ');
+    }
+
+    if (action === 'pull') {
+      return `cd ${quotedProjectPath} && git pull`;
+    }
+
+    if (action === 'up') {
+      return `cd ${quotedProjectPath} && docker compose up -d`;
+    }
+
+    if (action === 'down') {
+      return `cd ${quotedProjectPath} && docker compose down`;
+    }
+
+    return `cd ${quotedProjectPath} && docker compose logs --no-color --tail=200`;
+  }
+
+  private async runStatus(
+    server: ResolvedServerConfig,
+    projectPath: string,
+  ): Promise<void> {
+    const quotedProjectPath = shellQuote(projectPath);
+    const jsonCommand = `cd ${quotedProjectPath} && docker compose ps --format json`;
+    const jsonResult = await this.sshService.execute(server, jsonCommand);
+
+    if (jsonResult.success) {
+      printJson({
+        status: 'ok',
+        data: {
+          action: 'status',
+          stdout: jsonResult.stdout,
+        },
+      });
+      return;
+    }
+
+    const fallbackCommand = `cd ${quotedProjectPath} && docker compose ps`;
+    const fallbackResult = await this.sshService.execute(
+      server,
+      fallbackCommand,
+    );
+
+    if (!fallbackResult.success) {
+      printSshError(fallbackResult, fallbackCommand);
+      return;
+    }
+
+    printJson({
+      status: 'ok',
+      data: {
+        action: 'status',
+        raw: fallbackResult.stdout,
+      },
+    });
+  }
+}