biaws 0.1.0

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "biaws",
+  "version": "0.1.0",
+  "description": "CLI do Bondia Workspaces para configuração do ambiente local",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fbondia/biaws.git",
+    "directory": "biaws-cli"
+  },
+  "homepage": "https://github.com/fbondia/biaws#readme",
+  "bugs": {
+    "url": "https://github.com/fbondia/biaws/issues"
+  },
+  "keywords": [
+    "biaws",
+    "bondia-workspaces",
+    "cli",
+    "oclif"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "bin": {
+    "biaws": "bin/biaws.js"
+  },
+  "files": [
+    "bin",
+    "docs",
+    "LICENSE",
+    "shared",
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "oclif": {
+    "bin": "biaws",
+    "dirname": "biaws",
+    "commands": "./src/commands",
+    "topicSeparator": " "
+  },
+  "scripts": {
+    "start": "node bin/biaws.js",
+    "format": "prettier --config ../prettier/.prettierrc --ignore-path ../.prettierignore --write .",
+    "format:check": "prettier --config ../prettier/.prettierrc --ignore-path ../.prettierignore --check .",
+    "check": "node scripts/check-syntax.mjs",
+    "test": "node --test",
+    "package:verify": "node scripts/verify-package.mjs",
+    "release:check": "npm run format:check && npm run check && npm test && npm run package:verify",
+    "publish:npm": "../scripts/publish-biaws-cli.sh",
+    "prepack": "npm run package:verify"
+  },
+  "devDependencies": {
+    "prettier": "^3.7.4"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "@oclif/core": "^4.13.5"
+  }
+}

package/shared/skillPackage.js

@@ -0,0 +1,100 @@
+import crypto from "node:crypto";
+import { lstat, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+const MAX_FILES = 200;
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_PACKAGE_BYTES = 2 * 1024 * 1024;
+
+function normalizeRelativePath(value) {
+  return value.split(path.sep).join("/");
+}
+
+async function collectFiles(root, current = root, result = []) {
+  const entries = await readdir(current, { withFileTypes: true });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const absolutePath = path.join(current, entry.name);
+    const relativePath = normalizeRelativePath(
+      path.relative(root, absolutePath),
+    );
+    if (entry.isSymbolicLink())
+      throw new Error(`Links simbólicos não são permitidos: ${relativePath}`);
+    if (entry.isDirectory()) await collectFiles(root, absolutePath, result);
+    else if (entry.isFile()) result.push({ absolutePath, path: relativePath });
+  }
+  return result;
+}
+
+function extractFrontmatter(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(markdown);
+  if (!match) return {};
+  const values = {};
+  for (const line of match[1].split(/\r?\n/u)) {
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim();
+    if (key && value) values[key] = value;
+  }
+  return values;
+}
+
+export async function buildSkillPayload(directory, options = {}) {
+  const root = path.resolve(directory);
+  const stats = await lstat(root);
+  if (!stats.isDirectory())
+    throw new Error(`Diretório de skill inválido: ${root}`);
+  const entries = await collectFiles(root);
+  if (!entries.some((entry) => entry.path === "SKILL.md")) {
+    throw new Error(`SKILL.md não encontrado em ${root}`);
+  }
+  if (entries.length > MAX_FILES)
+    throw new Error(`A skill excede o limite de ${MAX_FILES} arquivos`);
+
+  let totalBytes = 0;
+  const files = [];
+  for (const entry of entries) {
+    const content = await readFile(entry.absolutePath);
+    if (content.length > MAX_FILE_BYTES)
+      throw new Error(`Arquivo excede ${MAX_FILE_BYTES} bytes: ${entry.path}`);
+    totalBytes += content.length;
+    if (totalBytes > MAX_PACKAGE_BYTES)
+      throw new Error(`A skill excede o limite de ${MAX_PACKAGE_BYTES} bytes`);
+    files.push({ path: entry.path, contentBase64: content.toString("base64") });
+  }
+  const skillMarkdown = await readFile(path.join(root, "SKILL.md"), "utf8");
+  const frontmatter = extractFrontmatter(skillMarkdown);
+  const skillId = String(
+    options.id || frontmatter.name || path.basename(root),
+  ).trim();
+  const description = String(
+    options.description || frontmatter.description || "",
+  ).trim();
+  if (!description) {
+    throw new Error(
+      "Descrição ausente; informe --description ou adicione description ao SKILL.md",
+    );
+  }
+  return {
+    skillId,
+    name: String(options.name || skillId),
+    description,
+    version: String(options.version || ""),
+    changelog: String(options.changelog || ""),
+    files,
+  };
+}
+
+export function checksumPackageFiles(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+    const content = Buffer.from(file.contentBase64, "base64");
+    const fileHash = crypto.createHash("sha256").update(content).digest("hex");
+    hash.update(file.path);
+    hash.update("\0");
+    hash.update(fileHash);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}

package/src/apiClient.js

@@ -0,0 +1,89 @@
+function trimTrailingSlash(value) {
+  return String(value || "").replace(/\/+$/u, "");
+}
+
+export function createApiClient(baseUrl, apiKey, workspaceId = "") {
+  const apiRoot = `${trimTrailingSlash(baseUrl)}/api`;
+  const root = `${apiRoot}/skills`;
+
+  async function request(path = "", options = {}, requestRoot = root) {
+    const response = await fetch(`${requestRoot}${path}`, {
+      ...options,
+      headers: {
+        Accept: "application/json",
+        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+        ...(workspaceId ? { "X-Biaws-Workspace-Id": workspaceId } : {}),
+        ...(options.body ? { "Content-Type": "application/json" } : {}),
+        ...options.headers,
+      },
+    });
+    const data = await response.json().catch(() => null);
+    if (!response.ok) {
+      const error = new Error(
+        data?.error?.message || `HTTP ${response.status}`,
+      );
+      error.statusCode = response.status;
+      error.code =
+        data?.error?.code ||
+        (response.status === 401
+          ? "UNAUTHENTICATED"
+          : response.status === 403
+            ? "FORBIDDEN"
+            : response.status === 404
+              ? "NOT_FOUND"
+              : response.status === 409
+                ? "CONFLICT"
+                : "ISSUE_API_ERROR");
+      throw error;
+    }
+    return data;
+  }
+
+  return {
+    request: (path, options = {}) => request(path, options, apiRoot),
+    identity: () => request("/auth/me", {}, apiRoot),
+    list: (options = {}) =>
+      request(options.includeDeprecated ? "?includeDeprecated=true" : ""),
+    get: (skillId, version) =>
+      request(
+        `/${encodeURIComponent(skillId)}${version ? `?version=${encodeURIComponent(version)}` : ""}`,
+      ),
+    download: (skillId, version) =>
+      request(
+        `/${encodeURIComponent(skillId)}/${encodeURIComponent(version)}/download`,
+      ),
+    publish: (payload) =>
+      request("", { method: "POST", body: JSON.stringify(payload) }),
+    monitoring: {
+      describeTemplate: (templateId, version) =>
+        request(
+          `/templates/${encodeURIComponent(templateId)}/versions/${encodeURIComponent(version)}/contract`,
+          {},
+          `${apiRoot}/monitoring`,
+        ),
+      validateTemplate: (templateId, version, sample) =>
+        request(
+          `/templates/${encodeURIComponent(templateId)}/versions/${encodeURIComponent(version)}/validate`,
+          { method: "POST", body: JSON.stringify({ sample }) },
+          `${apiRoot}/monitoring`,
+        ),
+      signal: (runtimeReference, payload) =>
+        request(
+          `/runtimes/${encodeURIComponent(runtimeReference)}/signals`,
+          { method: "POST", body: JSON.stringify(payload) },
+          `${apiRoot}/monitoring`,
+        ),
+      listSignals: (runtimeReference, options = {}) => {
+        const parameters = new URLSearchParams();
+        if (options.page) parameters.set("page", options.page);
+        if (options.limit) parameters.set("limit", options.limit);
+        const query = parameters.size ? `?${parameters}` : "";
+        return request(
+          `/runtimes/${encodeURIComponent(runtimeReference)}/signals${query}`,
+          {},
+          `${apiRoot}/monitoring`,
+        );
+      },
+    },
+  };
+}

package/src/baseCommands.js

@@ -0,0 +1,122 @@
+import {
+  access,
+  chmod,
+  mkdtemp,
+  mkdir,
+  readFile,
+  readdir,
+  stat,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { Command } from "@oclif/core";
+
+import { createApiClient } from "./apiClient.js";
+import {
+  resolveAuthenticatedContext,
+  resolveCommandContext,
+} from "./core/context.js";
+import { ProcessRunner } from "./core/processRunner.js";
+import { createPromptAdapter } from "./core/prompts.js";
+import {
+  CliLogger,
+  CliOutput,
+  createTerminalAdapter,
+} from "./core/terminal.js";
+
+export const TOOL_DIRECTORY = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+
+export function createCommandAdapters(overrides = {}) {
+  const environment = overrides.environment || { ...process.env };
+  const filesystem = overrides.filesystem || {
+    access,
+    chmod,
+    mkdtemp,
+    mkdir,
+    readFile,
+    readdir,
+    stat,
+    rm,
+    writeFile,
+  };
+  const terminal = overrides.terminal || createTerminalAdapter({ environment });
+  const processRunner =
+    overrides.processRunner ||
+    new ProcessRunner({
+      signalSource: process,
+      stdout: terminal.stdout,
+      stderr: terminal.stderr,
+    });
+  const prompts =
+    overrides.prompts || createPromptAdapter(terminal, overrides.promptOptions);
+  return Object.freeze({
+    apiFactory: overrides.apiFactory || createApiClient,
+    cwd: overrides.cwd || (() => process.cwd()),
+    environment,
+    filesystem,
+    processRunner,
+    prompts,
+    terminal,
+  });
+}
+
+export class BaseCommand extends Command {
+  constructor(argv, config, adapterOverrides = {}) {
+    super(argv, config);
+    this.adapters = createCommandAdapters(adapterOverrides);
+  }
+
+  output(options = {}) {
+    return new CliOutput(this.adapters.terminal, options);
+  }
+
+  logger(options = {}) {
+    return new CliLogger(this.adapters.terminal, options);
+  }
+
+  contextOptions(input = {}) {
+    return {
+      cwd: this.adapters.cwd(),
+      environment: this.adapters.environment,
+      filesystem: this.adapters.filesystem,
+      input,
+      terminal: this.adapters.terminal,
+      toolDirectory: TOOL_DIRECTORY,
+    };
+  }
+}
+
+export class LocalInstanceCommand extends BaseCommand {
+  localContext(input = {}) {
+    return resolveCommandContext(this.contextOptions(input));
+  }
+}
+
+export class AuthenticatedApiCommand extends BaseCommand {
+  async authenticatedContext(input = {}, options = {}) {
+    const context = await resolveAuthenticatedContext({
+      ...this.contextOptions(input),
+      requireWorkspace: Boolean(options.requireWorkspace),
+    });
+    return Object.freeze({
+      ...context,
+      api: this.adapters.apiFactory(
+        context.apiUrl,
+        context.apiKey,
+        context.workspaceId,
+      ),
+    });
+  }
+}
+
+export class ProjectCommand extends AuthenticatedApiCommand {
+  async projectContext(input = {}, options = {}) {
+    return this.authenticatedContext(input, options);
+  }
+}

package/src/commands/agent/configure.js

@@ -0,0 +1,3 @@
+import { createAgentCommand } from "../../compatibilityCommands.js";
+
+export default createAgentCommand("configure");

package/src/commands/agent/doctor.js

@@ -0,0 +1,3 @@
+import { createAgentCommand } from "../../compatibilityCommands.js";
+
+export default createAgentCommand("doctor");