biaws 0.1.0

package/src/commands/instance/setup.js

@@ -0,0 +1,349 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  buildExecutionPlan,
+  executeExecutionPlan,
+  summarizeExecutionPlan,
+  wizardFlags,
+} from "../../core/wizard.js";
+import {
+  contextFlags,
+  contextInput,
+  writeResult,
+} from "../../instance/command.js";
+import {
+  buildSetupConfiguration,
+  executeSetup,
+  validateInstanceName,
+  validatePort,
+  validatePublicUrl,
+} from "../../instance/service.js";
+
+const setupFlags = {
+  ...contextFlags,
+  ...wizardFlags,
+  name: Flags.string({ char: "n", description: "nome da instância" }),
+  "admin-email": Flags.string({
+    description: "e-mail do administrador inicial",
+  }),
+  "admin-name": Flags.string({ description: "nome do administrador inicial" }),
+  "public-url": Flags.string({ description: "origem pública HTTP(S) da UI" }),
+  "mongo-port": Flags.integer({ description: "porta externa do MongoDB" }),
+  "api-port": Flags.integer({ description: "porta externa da API" }),
+  "ui-port": Flags.integer({ description: "porta externa da UI" }),
+  storage: Flags.string({
+    options: ["volumes", "directories"],
+    description: "estratégia de storage",
+  }),
+  "storage-root": Flags.string({
+    description: "raiz dos diretórios persistentes",
+  }),
+  "mongo-path": Flags.string({
+    description: "diretório persistente do MongoDB",
+  }),
+  "issue-path": Flags.string({
+    description: "diretório persistente de issues",
+  }),
+  "request-path": Flags.string({
+    description: "diretório persistente de melhorias",
+  }),
+  "document-path": Flags.string({
+    description: "diretório persistente de documentos",
+  }),
+  "secret-path": Flags.string({
+    description: "diretório persistente do cofre",
+  }),
+  "demo-seed": Flags.boolean({
+    allowNo: true,
+    description: "carrega dados de demonstração",
+  }),
+  "disable-rate-limit": Flags.boolean({
+    description: "desabilita todas as camadas de rate limit",
+  }),
+  "api-rate-limit-max": Flags.integer({
+    description: "requisições por janela da API",
+  }),
+  "api-rate-limit-window": Flags.integer({
+    description: "janela da API em segundos",
+  }),
+  "auth-rate-limit-max": Flags.integer({
+    description: "requisições por janela de autenticação",
+  }),
+  "auth-rate-limit-window": Flags.integer({
+    description: "janela de autenticação em segundos",
+  }),
+  "api-key-rate-limit-max": Flags.integer({
+    description: "requisições por janela de API key",
+  }),
+  "api-key-rate-limit-window": Flags.integer({
+    description: "janela de API key em segundos",
+  }),
+};
+
+const definition = {
+  kind: "instance.setup",
+  questions: [
+    {
+      name: "name",
+      type: "input",
+      message: "Nome da instância",
+      environment: "BIAWS_INSTANCE",
+      validate: (value) => {
+        validateInstanceName(value);
+        return true;
+      },
+    },
+    {
+      name: "adminEmail",
+      flag: "admin-email",
+      type: "input",
+      message: "E-mail do administrador",
+      default: "admin@example.com",
+      validate: (value) =>
+        /^\S+@\S+\.\S+$/u.test(value) || "E-mail administrativo inválido.",
+    },
+    {
+      name: "adminName",
+      flag: "admin-name",
+      type: "input",
+      message: "Nome do administrador",
+      default: "Administrador",
+    },
+    {
+      name: "adminPassword",
+      type: "password",
+      message: "Senha inicial do administrador",
+      environment: "BIAWS_BOOTSTRAP_ADMIN_PASSWORD",
+      secret: true,
+    },
+    {
+      name: "uiPort",
+      flag: "ui-port",
+      type: "number",
+      message: "Porta da UI",
+      default: 4400,
+      validate: (value) => {
+        validatePort(value, "Porta UI");
+        return true;
+      },
+    },
+    {
+      name: "apiPort",
+      flag: "api-port",
+      type: "number",
+      message: "Porta da API",
+      default: 3100,
+      validate: (value) => {
+        validatePort(value, "Porta API");
+        return true;
+      },
+    },
+    {
+      name: "mongoPort",
+      flag: "mongo-port",
+      type: "number",
+      message: "Porta do MongoDB",
+      default: 27017,
+      validate: (value) => {
+        validatePort(value, "Porta MongoDB");
+        return true;
+      },
+    },
+    {
+      name: "publicUrl",
+      flag: "public-url",
+      type: "input",
+      message: "URL pública",
+      default: (values) => `http://localhost:${values.uiPort}`,
+      validate: (value) => {
+        validatePublicUrl(value);
+        return true;
+      },
+    },
+    {
+      name: "storage",
+      type: "select",
+      message: "Estratégia de storage",
+      choices: [
+        { name: "Volumes Docker", value: "volumes" },
+        { name: "Diretórios no host", value: "directories" },
+      ],
+      default: "volumes",
+    },
+    {
+      name: "storageRoot",
+      flag: "storage-root",
+      type: "input",
+      message: "Raiz de storage",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "mongoPath",
+      flag: "mongo-path",
+      type: "input",
+      message: "Diretório MongoDB",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "issuePath",
+      flag: "issue-path",
+      type: "input",
+      message: "Diretório de issues",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "requestPath",
+      flag: "request-path",
+      type: "input",
+      message: "Diretório de melhorias",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "documentPath",
+      flag: "document-path",
+      type: "input",
+      message: "Diretório de documentos",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "secretPath",
+      flag: "secret-path",
+      type: "input",
+      message: "Diretório do cofre",
+      required: false,
+      when: (values) => values.storage === "directories",
+    },
+    {
+      name: "apiRateLimitMax",
+      flag: "api-rate-limit-max",
+      type: "number",
+      message: "Rate limit da API",
+      default: 300,
+    },
+    {
+      name: "apiRateLimitWindow",
+      flag: "api-rate-limit-window",
+      type: "number",
+      message: "Janela da API (s)",
+      default: 60,
+    },
+    {
+      name: "authRateLimitMax",
+      flag: "auth-rate-limit-max",
+      type: "number",
+      message: "Rate limit de autenticação",
+      default: 100,
+    },
+    {
+      name: "authRateLimitWindow",
+      flag: "auth-rate-limit-window",
+      type: "number",
+      message: "Janela de autenticação (s)",
+      default: 10,
+    },
+    {
+      name: "apiKeyRateLimitMax",
+      flag: "api-key-rate-limit-max",
+      type: "number",
+      message: "Rate limit de API key",
+      default: 1000,
+    },
+    {
+      name: "apiKeyRateLimitWindow",
+      flag: "api-key-rate-limit-window",
+      type: "number",
+      message: "Janela de API key (s)",
+      default: 3600,
+    },
+    {
+      name: "disableRateLimit",
+      flag: "disable-rate-limit",
+      type: "confirm",
+      message: "Desabilitar rate limiting?",
+      default: false,
+    },
+    {
+      name: "demoSeed",
+      flag: "demo-seed",
+      type: "confirm",
+      message: "Carregar dados de demonstração?",
+      default: false,
+    },
+  ],
+};
+
+export default class InstanceSetup extends LocalInstanceCommand {
+  static description =
+    "cria ou reconcilia uma instância local por plano idempotente";
+  static examples = [
+    "<%= config.bin %> instance setup --interactive",
+    "BIAWS_BOOTSTRAP_ADMIN_PASSWORD=... <%= config.bin %> instance setup --name local --defaults --yes --non-interactive",
+  ];
+  static flags = setupFlags;
+
+  async run() {
+    const { flags } = await this.parse(InstanceSetup);
+    const context = await this.localContext(contextInput(flags, flags.name));
+    const plan = await buildExecutionPlan(definition, {
+      environment: this.adapters.environment,
+      flags,
+      options: flags,
+      promptAdapter: this.adapters.prompts,
+      terminal: this.adapters.terminal,
+    });
+    const configuration = await buildSetupConfiguration(
+      Object.fromEntries(
+        definition.questions.map((question) => [
+          question.name,
+          plan.get(question.name),
+        ]),
+      ),
+      context,
+      this.adapters.filesystem,
+    );
+    if (configuration.storageChanged) {
+      this.output().diagnostic(
+        "Aviso: o storage mudou; dados existentes não serão movidos automaticamente.",
+      );
+    }
+    this.output().diagnostic(
+      `Plano validado: ${JSON.stringify(summarizeExecutionPlan(plan))}`,
+    );
+    const result = await executeExecutionPlan(
+      plan,
+      () =>
+        executeSetup(
+          configuration,
+          context,
+          this.adapters.processRunner,
+          this.adapters.environment,
+          { silent: flags.json },
+        ),
+      {
+        options: flags,
+        promptAdapter: this.adapters.prompts,
+        terminal: this.adapters.terminal,
+      },
+    );
+    writeResult(
+      this,
+      result,
+      (value) =>
+        [
+          "Configuração concluída.",
+          `Instância: ${value.name}`,
+          `UI: ${value.ui}`,
+          `API: ${value.api}`,
+          `MongoDB: ${value.mongo}`,
+          `Status: ${value.commands.status}`,
+        ].join("\n"),
+      flags.json,
+    );
+  }
+}

package/src/commands/instance/show.js

@@ -0,0 +1,31 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+  instanceSummary,
+  writeResult,
+} from "../../instance/command.js";
+import { getInstance } from "../../instance/service.js";
+
+export default class InstanceShow extends LocalInstanceCommand {
+  static description = "exibe a configuração não sensível de uma instância";
+  static args = { instance: instanceArgument };
+  static flags = {
+    ...contextFlags,
+    json: Flags.boolean({ description: "emite JSON" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceShow);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const { env, ...instance } = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    writeResult(this, instance, instanceSummary, flags.json);
+  }
+}

package/src/commands/instance/start.js

@@ -0,0 +1,32 @@
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+} from "../../instance/command.js";
+import { getInstance, operateInstance } from "../../instance/service.js";
+
+export default class InstanceStart extends LocalInstanceCommand {
+  static description = "inicia os serviços de uma instância e aguarda saúde";
+  static args = { instance: instanceArgument };
+  static flags = contextFlags;
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceStart);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    await operateInstance(
+      instance,
+      context,
+      this.adapters.processRunner,
+      "start",
+    );
+    this.output().result(
+      `Instância ${instance.name} iniciada. UI: ${instance.publicUrl}`,
+    );
+  }
+}

package/src/commands/instance/status.js

@@ -0,0 +1,42 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+  writeResult,
+} from "../../instance/command.js";
+import { getInstance, operateInstance } from "../../instance/service.js";
+
+export default class InstanceStatus extends LocalInstanceCommand {
+  static description = "consulta o estado dos containers de uma instância";
+  static args = { instance: instanceArgument };
+  static flags = {
+    ...contextFlags,
+    json: Flags.boolean({ description: "emite JSON" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceStatus);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    const result = await operateInstance(
+      instance,
+      context,
+      this.adapters.processRunner,
+      "status",
+    );
+    writeResult(
+      this,
+      result,
+      (value) =>
+        value.output || `Nenhum container ativo para ${value.instance}.`,
+      flags.json,
+    );
+  }
+}

package/src/commands/instance/stop.js

@@ -0,0 +1,30 @@
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+} from "../../instance/command.js";
+import { getInstance, operateInstance } from "../../instance/service.js";
+
+export default class InstanceStop extends LocalInstanceCommand {
+  static description = "para os serviços de uma instância sem remover dados";
+  static args = { instance: instanceArgument };
+  static flags = contextFlags;
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceStop);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    await operateInstance(
+      instance,
+      context,
+      this.adapters.processRunner,
+      "stop",
+    );
+    this.output().result(`Instância ${instance.name} parada.`);
+  }
+}

package/src/commands/instance.js

@@ -0,0 +1,18 @@
+import { Help } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../baseCommands.js";
+
+export default class Instance extends LocalInstanceCommand {
+  static description =
+    "Instala, configura e opera instâncias locais do Bondia Workspaces";
+  static examples = [
+    "<%= config.bin %> instance setup",
+    "<%= config.bin %> instance status",
+    "<%= config.bin %> instance backup",
+  ];
+
+  async run() {
+    await this.parse(Instance);
+    await new Help(this.config).showHelp(["instance"]);
+  }
+}

package/src/commands/issues/get.js

@@ -0,0 +1,16 @@
+import { Args } from "@oclif/core";
+import { connectionFlags, ReadCommand } from "../../domain/readCommand.js";
+export default class IssueGet extends ReadCommand {
+  static description = "Obtém uma issue por ID ou código";
+  static args = { id: Args.string({ required: true }) };
+  static flags = connectionFlags;
+  async run() {
+    const { args, flags } = await this.parse(IssueGet);
+    const result = await this.read(flags, (api) => api.issue(args.id), {
+      resource: "issue",
+      operation: "get",
+      requireWorkspace: true,
+    });
+    this.emit(flags, result, (p) => JSON.stringify(p.issue || p, null, 2));
+  }
+}

package/src/commands/issues/list.js

@@ -0,0 +1,51 @@
+import { Flags } from "@oclif/core";
+import {
+  connectionFlags,
+  listFlags,
+  ReadCommand,
+} from "../../domain/readCommand.js";
+import { table } from "../../domain/readService.js";
+export default class IssueList extends ReadCommand {
+  static description = "Lista issues no escopo informado";
+  static flags = {
+    ...connectionFlags,
+    ...listFlags,
+    application: Flags.string({ description: "ID da aplicação" }),
+    component: Flags.string({ description: "ID do componente" }),
+    severity: Flags.string({ description: "filtra por severidade" }),
+  };
+  async run() {
+    const { flags } = await this.parse(IssueList);
+    const result = await this.read(
+      flags,
+      (api, c) =>
+        api.issues({
+          workspaceId: c.workspaceId,
+          applicationId: flags.application,
+          componentId: flags.component,
+          status: flags.status,
+          severity: flags.severity,
+          q: flags.search,
+          page: flags.page,
+          limit: flags.limit,
+        }),
+      {
+        resource: "issues",
+        operation: "list",
+        requireWorkspace: true,
+        scope: (c) => ({
+          workspaceId: c.workspaceId,
+          applicationId: flags.application,
+        }),
+      },
+    );
+    this.emit(flags, result, (p) =>
+      table(p.items || [], [
+        ["ID", (x) => x.clientCode || x.id],
+        ["TÍTULO", (x) => x.title || x.summary],
+        ["STATUS", (x) => x.status],
+        ["SEVERIDADE", (x) => x.severity],
+      ]),
+    );
+  }
+}

package/src/commands/issues/transition.js

@@ -0,0 +1,33 @@
+import { Args, Flags } from "@oclif/core";
+import { WriteCommand, writeFlags } from "../../domain/writeCommand.js";
+
+export default class IssueTransition extends WriteCommand {
+  static description = "Executa uma transição suportada de status de issue";
+  static args = { issue: Args.string({ required: true }) };
+  static flags = {
+    ...writeFlags,
+    status: Flags.string({ required: true, description: "novo status" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(IssueTransition);
+    return this.write(
+      flags,
+      "issue",
+      async (service) => {
+        const payload = await service.issue(args.issue);
+        const issue = payload.issue || payload;
+        return {
+          resource: "issue",
+          operation: "status.transition",
+          applicationId: issue.applicationId || null,
+          currentStatus: issue.status,
+          status: flags.status,
+          label: `Issue ${issue.code || issue.id || issue._id || args.issue}`,
+          entity: issue,
+        };
+      },
+      (service, plan) => service.updateIssueStatus(args.issue, plan.status),
+    );
+  }
+}

package/src/commands/issues.js

@@ -0,0 +1,7 @@
+import { Command } from "@oclif/core";
+export default class Issues extends Command {
+  static description = "Consulta incidentes e issues pela API";
+  async run() {
+    await this.config.runCommand("help", ["issues"]);
+  }
+}

package/src/commands/monitoring/describe.js

@@ -0,0 +1,13 @@
+import { Flags } from "@oclif/core";
+import { createMonitoringCommand } from "../../compatibilityCommands.js";
+
+export default createMonitoringCommand("describe", {
+  description: "descreve um contrato de monitoramento versionado",
+  flags: {
+    template: Flags.string({ description: "ID do template", required: true }),
+    "template-version": Flags.string({
+      description: "versão do template",
+      required: true,
+    }),
+  },
+});

package/src/commands/monitoring/signal.js

@@ -0,0 +1,25 @@
+import { Flags } from "@oclif/core";
+import {
+  createMonitoringCommand,
+  runtimeArgument,
+} from "../../compatibilityCommands.js";
+
+export default createMonitoringCommand("signal", {
+  description: "registra um sinal idempotente de saúde do runtime",
+  args: { runtime: runtimeArgument },
+  flags: {
+    source: Flags.string({ description: "origem do sinal", required: true }),
+    status: Flags.string({
+      options: ["unknown", "healthy", "degraded", "unavailable", "stopped"],
+    }),
+    "signal-id": Flags.string({ description: "identificador idempotente" }),
+    "observed-at": Flags.string({ description: "instante observado" }),
+    message: Flags.string({ description: "mensagem do sinal" }),
+    metadata: Flags.string({ description: "objeto JSON de metadados" }),
+    "metadata-profile": Flags.string({ description: "perfil dos metadados" }),
+    template: Flags.string({ description: "ID do template" }),
+    "template-version": Flags.string({ description: "versão do template" }),
+    payload: Flags.string({ description: "payload JSON do template" }),
+  },
+  positional: (args) => [args.runtime],
+});

package/src/commands/monitoring/signals.js

@@ -0,0 +1,17 @@
+import { Flags } from "@oclif/core";
+import {
+  createMonitoringCommand,
+  runtimeArgument,
+} from "../../compatibilityCommands.js";
+
+export default createMonitoringCommand("signals", {
+  description: "lista sinais recebidos por um runtime",
+  args: { runtime: runtimeArgument },
+  flags: {
+    limit: Flags.integer({ description: "quantidade máxima" }),
+    page: Flags.integer({ description: "página" }),
+    status: Flags.string({ description: "filtra por estado" }),
+    source: Flags.string({ description: "filtra por origem" }),
+  },
+  positional: (args) => [args.runtime],
+});

package/src/commands/monitoring/validate.js

@@ -0,0 +1,14 @@
+import { Flags } from "@oclif/core";
+import { createMonitoringCommand } from "../../compatibilityCommands.js";
+
+export default createMonitoringCommand("validate", {
+  description: "valida um payload sem persistir sinal",
+  flags: {
+    template: Flags.string({ description: "ID do template", required: true }),
+    "template-version": Flags.string({
+      description: "versão do template",
+      required: true,
+    }),
+    payload: Flags.string({ description: "payload JSON", required: true }),
+  },
+});