npm - @beaglabs/chaveta - Versions diffs - 0.0.1 - Mend

@beaglabs/chaveta 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +303 -0
package/package.json +40 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+// src/index.ts
+import { program } from "commander";
+// src/commands/login.ts
+import { createServer } from "http";
+import open from "open";
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".chaveta");
+var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function saveCredentials(creds) {
+  ensureDir();
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), "utf-8");
+}
+function loadCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function clearCredentials() {
+  if (existsSync(CREDENTIALS_FILE)) {
+    writeFileSync(CREDENTIALS_FILE, "", "utf-8");
+  }
+}
+function getBaseUrl() {
+  return process.env.CHAVETA_API_URL ?? "https://chaveta.beaglabs.com";
+}
+function getAuthHeaders() {
+  const clientId = process.env.CHAVETA_CLIENT_ID;
+  const clientSecret = process.env.CHAVETA_CLIENT_SECRET;
+  if (clientId && clientSecret) {
+    const basic = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+    return { authorization: `Basic ${basic}` };
+  }
+  const creds = loadCredentials();
+  if (creds?.accessToken) {
+    return { authorization: `Bearer ${creds.accessToken}` };
+  }
+  return {};
+}
+// src/commands/login.ts
+async function login() {
+  const baseUrl = getBaseUrl();
+  const port = 9876;
+  const redirectUri = `http://localhost:${port}/callback`;
+  console.log("Opening browser for authentication...");
+  const tokenPromise = new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        if (!code) {
+          res.writeHead(400);
+          res.end("Missing authorization code");
+          reject(new Error("Missing authorization code"));
+          server.close();
+          return;
+        }
+        try {
+          const tokenRes = await fetch(`${baseUrl}/api/auth/token`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              grant_type: "authorization_code",
+              code,
+              redirect_uri: redirectUri
+            })
+          });
+          if (!tokenRes.ok) {
+            throw new Error(`Token exchange failed: ${tokenRes.status}`);
+          }
+          const data = await tokenRes.json();
+          saveCredentials({
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+          });
+          res.writeHead(200, { "content-type": "text/html" });
+          res.end("<html><body><h2>Authenticated! You can close this tab.</h2></body></html>");
+          resolve(data.access_token);
+        } catch (err) {
+          res.writeHead(500);
+          res.end("Authentication failed");
+          reject(err);
+        } finally {
+          server.close();
+        }
+      }
+    });
+    server.listen(port, () => {
+      const authUrl = `${baseUrl}/api/auth/authorize?redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code`;
+      open(authUrl);
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 120 seconds"));
+    }, 12e4);
+  });
+  await tokenPromise;
+  console.log("Logged in successfully.");
+}
+// src/commands/generate.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+// src/types.ts
+var FOXGLOVE_SCHEMAS = [
+  "foxglove.PointCloud",
+  "foxglove.GeoJSON",
+  "foxglove.Grid",
+  "foxglove.LocationFix"
+];
+// src/commands/generate.ts
+async function generateCommand(options) {
+  if (!FOXGLOVE_SCHEMAS.includes(options.schema)) {
+    console.error(`Invalid schema: ${options.schema}`);
+    console.error(`Valid schemas: ${FOXGLOVE_SCHEMAS.join(", ")}`);
+    process.exit(1);
+  }
+  const headers = getAuthHeaders();
+  if (!headers.authorization) {
+    console.error("Not authenticated. Run `chaveta login` or set CHAVETA_CLIENT_ID and CHAVETA_CLIENT_SECRET.");
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const outputMode = options.view ? "view" : "stream";
+  console.log(`Generating ${options.count} ${options.schema} fixture(s)...`);
+  console.log(`Scenario: "${options.scenario}"`);
+  const res = await fetch(`${baseUrl}/api/generate`, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      schema: options.schema,
+      scenario: options.scenario,
+      count: options.count,
+      seed: options.seed,
+      outputMode
+    })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    console.error(`Generation failed: ${err.error ?? res.statusText}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  console.log(`Queued: ${data.id}`);
+  const result = await pollForCompletion(baseUrl, data.id, headers);
+  if (result.status === "failed") {
+    console.error("Generation failed.");
+    process.exit(1);
+  }
+  if (result.view_url) {
+    console.log(`
+  Preview: ${result.view_url}`);
+    console.log(`  Expires in 24h
+`);
+  }
+  if (options.output && result.view_url) {
+    const outputDir = options.output;
+    if (!existsSync2(outputDir)) {
+      mkdirSync2(outputDir, { recursive: true });
+    }
+    const mcapRes = await fetch(result.view_url, {
+      headers: { accept: "application/octet-stream" }
+    });
+    if (mcapRes.ok) {
+      const buffer = Buffer.from(await mcapRes.arrayBuffer());
+      const filename = `${data.id}.mcap`;
+      writeFileSync2(join2(outputDir, filename), buffer);
+      console.log(`  Saved: ${join2(outputDir, filename)}`);
+    }
+  }
+}
+async function pollForCompletion(baseUrl, id, headers, maxAttempts = 60) {
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    const res = await fetch(`${baseUrl}/api/generate/${id}`, { headers });
+    if (!res.ok) continue;
+    const data = await res.json();
+    if (data.status === "complete" || data.status === "failed") {
+      return data;
+    }
+    if (i % 5 === 0) {
+      process.stdout.write(".");
+    }
+  }
+  return { status: "timeout" };
+}
+// src/commands/clients.ts
+async function createClient(name) {
+  const headers = getAuthHeaders();
+  if (!headers.authorization) {
+    console.error("Not authenticated. Run `chaveta login` first.");
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const res = await fetch(`${baseUrl}/api/auth/oauth2/create-client`, {
+    method: "POST",
+    headers: { ...headers, "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: name,
+      grant_types: ["client_credentials"],
+      token_endpoint_auth_method: "client_secret_post"
+    })
+  });
+  if (!res.ok) {
+    console.error(`Failed to create client: ${res.statusText}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  console.log("\nClient created successfully.\n");
+  console.log(`  CHAVETA_CLIENT_ID=${data.client_id}`);
+  console.log(`  CHAVETA_CLIENT_SECRET=${data.client_secret}`);
+  console.log("\n  Save the secret now \u2014 it will not be shown again.\n");
+}
+async function listClients() {
+  const headers = getAuthHeaders();
+  if (!headers.authorization) {
+    console.error("Not authenticated. Run `chaveta login` first.");
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const res = await fetch(`${baseUrl}/api/auth/oauth2/get-clients`, { headers });
+  if (!res.ok) {
+    console.error(`Failed to list clients: ${res.statusText}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  if (data.length === 0) {
+    console.log("No clients found.");
+    return;
+  }
+  console.log("\nNAME                  CLIENT_ID              CREATED");
+  console.log("\u2500".repeat(65));
+  for (const client of data) {
+    const name = (client.client_name ?? "").padEnd(20);
+    const id = client.client_id.padEnd(22);
+    const created = new Date(client.createdAt).toISOString().split("T")[0];
+    console.log(`${name}  ${id}  ${created}`);
+  }
+  console.log();
+}
+async function revokeClient(clientId) {
+  const headers = getAuthHeaders();
+  if (!headers.authorization) {
+    console.error("Not authenticated. Run `chaveta login` first.");
+    process.exit(1);
+  }
+  const baseUrl = getBaseUrl();
+  const res = await fetch(`${baseUrl}/api/auth/oauth2/delete-client`, {
+    method: "POST",
+    headers: { ...headers, "content-type": "application/json" },
+    body: JSON.stringify({ client_id: clientId })
+  });
+  if (!res.ok) {
+    console.error(`Failed to revoke client: ${res.statusText}`);
+    process.exit(1);
+  }
+  console.log(`Revoked client: ${clientId}`);
+}
+// src/index.ts
+program.name("chaveta").description("Generative test fixtures for robotics CI").version("0.0.1");
+program.command("login").description("Authenticate via GitHub OAuth").action(login);
+program.command("logout").description("Clear stored credentials").action(() => {
+  clearCredentials();
+  console.log("Logged out.");
+});
+program.command("generate").description("Generate Foxglove-compatible test fixtures").requiredOption("--schema <schema>", "Foxglove schema (foxglove.PointCloud, foxglove.GeoJSON, foxglove.Grid, foxglove.LocationFix)").requiredOption("--scenario <scenario>", "Natural language scenario description").option("--count <count>", "Number of fixtures to generate", "1").option("--seed <seed>", "Deterministic seed for reproducibility").option("--output <dir>", "Output directory for MCAP files").option("--view", "Upload and return an ephemeral viewer link").action((opts) => {
+  generateCommand({
+    schema: opts.schema,
+    scenario: opts.scenario,
+    count: parseInt(opts.count, 10),
+    seed: opts.seed,
+    output: opts.output,
+    view: opts.view ?? !opts.output
+  });
+});
+var clients = program.command("clients").description("Manage M2M client credentials for CI");
+clients.command("create").description("Create a new M2M client").requiredOption("--name <name>", "Client name").action((opts) => createClient(opts.name));
+clients.command("list").description("List all clients").action(listClients);
+clients.command("revoke").description("Revoke a client").argument("<client_id>", "Client ID to revoke").action(revokeClient);
+program.parse();

package/package.json ADDED Viewed

@@ -0,0 +1,40 @@
+{
+  "name": "@beaglabs/chaveta",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "chaveta": "./dist/index.js"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "robotics",
+    "foxglove",
+    "mcap",
+    "pointcloud",
+    "synthetic-data",
+    "ci",
+    "test-fixtures",
+    "beaglabs"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beaglabs/chaveta"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}