farseer-cli 1.0.0

package/dist/services/farseerService.js

@@ -0,0 +1,614 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var farseerService_exports = {};
+__export(farseerService_exports, {
+  FarseerService: () => FarseerService,
+  loginWithBrowser: () => loginWithBrowser,
+  loginWithPassword: () => loginWithPassword,
+  refreshAccessToken: () => refreshAccessToken
+});
+module.exports = __toCommonJS(farseerService_exports);
+var farseer = __toESM(require("farseer-client"));
+var import_configService = require("./configService");
+class FarseerService {
+  constructor(credential) {
+    this.credential = credential;
+    this.client = new farseer.FarseerClient({
+      basePath: credential.basePath,
+      headers: {
+        "X-TENANT-ID": credential.tenantId,
+        "X-API-KEY": credential.apiKey
+      }
+    });
+  }
+  static fromUserAuth(tenant, basePath) {
+    const auth = (0, import_configService.getUserAuth)();
+    if (!auth) return null;
+    const service = new FarseerService({
+      type: "apiKey",
+      tenantId: tenant,
+      apiKey: "",
+      basePath
+    });
+    service.client = new farseer.FarseerClient({
+      basePath,
+      headers: {
+        "X-TENANT-ID": tenant
+      },
+      accessToken: auth.accessToken
+    });
+    return service;
+  }
+  async testConnection() {
+    try {
+      await this.client.getItemByPath(["Files"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getFilesFolder() {
+    try {
+      const item = await this.client.getItemByPath(["Files"]);
+      return {
+        id: item.id,
+        name: item.name,
+        type: item.type
+      };
+    } catch {
+      return null;
+    }
+  }
+  async listFiles(folderPath = ["Files"]) {
+    const files = [];
+    try {
+      const folder = await this.client.getItemByPath(folderPath);
+      const folderContent = await this.client.folders.listItemsBatch([{ id: folder.id }]);
+      for (const item of folderContent[0]?.items || []) {
+        const itemPath = [...folderPath.slice(1), item.name].join("/");
+        if (item.type === farseer.FolderItemType.Folder) {
+          const subFiles = await this.listFiles([...folderPath, item.name]);
+          files.push(...subFiles);
+        } else if (item.type === farseer.FolderItemType.FarseerFile && "reference" in item) {
+          files.push({
+            name: item.name,
+            path: itemPath,
+            reference: item.reference
+          });
+        }
+      }
+    } catch (error) {
+      return [];
+    }
+    return files;
+  }
+  async getFileContent(reference) {
+    const blob = await this.client.farseerFiles.get(reference);
+    return await blob.text();
+  }
+  async createFile(content, fileName, folderPath = ["Files"]) {
+    await this.ensureFolderPath(folderPath);
+    const folder = await this.client.getItemByPath(folderPath);
+    const blob = content instanceof Buffer ? new Blob([content]) : new Blob([content]);
+    const file = new farseer.WebFile([blob], fileName);
+    await this.client.farseerFiles.create(file, "GENERAL", folder.id.toString());
+  }
+  async updateFile(reference, content, fileName) {
+    const blob = content instanceof Buffer ? new Blob([content]) : new Blob([content]);
+    const file = new farseer.WebFile([blob], fileName);
+    await this.client.farseerFiles.update(reference, file);
+  }
+  async deleteFile(reference) {
+    await this.client.farseerFiles.remove(reference);
+  }
+  async ensureFolderPath(folderPath) {
+    let currentPath = [];
+    for (const segment of folderPath) {
+      currentPath.push(segment);
+      try {
+        await this.client.getItemByPath(currentPath);
+      } catch {
+        if (currentPath.length > 1) {
+          const parentPath = currentPath.slice(0, -1);
+          const parent = await this.client.getItemByPath(parentPath);
+          await this.client.folders.create({
+            parentId: parent.id,
+            name: segment,
+            allowedTypes: []
+          });
+        }
+      }
+    }
+  }
+  async getFileByPath(filePath) {
+    const pathParts = ["Files", ...filePath.split("/")];
+    const fileName = pathParts.pop();
+    const folderPath = pathParts;
+    try {
+      const folder = await this.client.getItemByPath(folderPath);
+      const folderContent = await this.client.folders.listItemsBatch([{ id: folder.id }]);
+      for (const item of folderContent[0]?.items || []) {
+        if (item.name === fileName && item.type === farseer.FolderItemType.FarseerFile && "reference" in item) {
+          return {
+            name: item.name,
+            path: filePath,
+            reference: item.reference
+          };
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  async getFileMetadata(reference) {
+    try {
+      const metadata = await this.client.farseerFiles.getMetadata(reference);
+      return {
+        uploadTime: metadata.uploadTime?.toISOString(),
+        uploader: metadata.uploader ? {
+          id: metadata.uploader.id,
+          email: metadata.uploader.email || "",
+          firstName: metadata.uploader.firstName || "",
+          lastName: metadata.uploader.lastName || ""
+        } : void 0,
+        size: metadata.size
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  async getFileContentAsBuffer(reference) {
+    const blob = await this.client.farseerFiles.get(reference);
+    const arrayBuffer = await blob.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  isTextFile(filename) {
+    const ext = filename.toLowerCase().split(".").pop() || "";
+    return ["ts", "js", "mjs", "cjs", "json", "txt", "md", "csv", "xml", "html", "css", "yaml", "yml"].includes(ext);
+  }
+  isBinaryFile(filename) {
+    return !this.isTextFile(filename);
+  }
+  // ==================== Apps (Remote Jobs) API ====================
+  /**
+   * List all apps (Remote Jobs) on the tenant
+   */
+  async listApps() {
+    const response = await this.apiRequest("/remoteJobs", "GET");
+    return response.map((app) => ({
+      id: app.id,
+      name: app.name,
+      type: "REMOTE_JOB",
+      reference: String(app.id)
+    }));
+  }
+  /**
+   * Get app details by reference ID
+   */
+  async getApp(referenceId) {
+    try {
+      return await this.apiRequest(`/remoteJobs/${referenceId}`, "GET");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get app by name
+   */
+  async getAppByName(name) {
+    const apps = await this.listApps();
+    const app = apps.find((a) => a.name.toLowerCase() === name.toLowerCase());
+    if (!app) {
+      return null;
+    }
+    return this.getApp(app.reference);
+  }
+  /**
+   * Create a new app
+   */
+  async createApp(name) {
+    const appsFolderId = await this.getAppsFolderId();
+    if (!appsFolderId) {
+      throw new Error("Apps folder not found");
+    }
+    return await this.apiRequest("/remoteJobs", "POST", {
+      folderId: appsFolderId,
+      name
+    });
+  }
+  /**
+   * Update an app
+   */
+  async updateApp(referenceId, update) {
+    await this.apiRequest(`/remoteJobs/${referenceId}`, "PUT", {
+      ...update,
+      schedule: null,
+      runnerName: null,
+      predefinedActions: []
+    });
+    const app = await this.getApp(referenceId);
+    if (!app) {
+      throw new Error("Failed to fetch updated app");
+    }
+    return app;
+  }
+  /**
+   * Delete an app
+   */
+  async deleteApp(referenceId) {
+    await this.apiRequest(`/remoteJobs/${referenceId}`, "DELETE");
+  }
+  /**
+   * Get script files available for apps
+   */
+  async getScriptFiles() {
+    const allFiles = await this.listFiles(["Files"]);
+    return allFiles.filter((f) => f.name.endsWith(".ts") || f.name.endsWith(".js")).map((f) => ({
+      id: f.reference,
+      name: f.name
+    }));
+  }
+  /**
+   * Export the entire model structure
+   */
+  async exportModel() {
+    return this.apiRequest("/model/export", "POST");
+  }
+  /**
+   * Get the Apps folder ID
+   */
+  async getAppsFolderId() {
+    try {
+      const item = await this.client.getItemByPath(["Apps"]);
+      return item.id;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Make a direct API request (for endpoints not in farseer-client)
+   */
+  async apiRequest(endpoint, method, body) {
+    const url = `${this.credential.basePath}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-TENANT-ID": this.credential.tenantId,
+      "X-API-KEY": this.credential.apiKey,
+      "x-api-version": "3.3.0"
+    };
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+}
+async function loginWithPassword(email, password) {
+  const tokenUrl = "https://login.farseer.io/auth/realms/master/protocol/openid-connect/token";
+  try {
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "password",
+        client_id: "security-admin-console",
+        username: email,
+        password
+      })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresIn: data.expires_in
+    };
+  } catch {
+    return null;
+  }
+}
+function getErrorPage(title, message) {
+  return `
+        <html>
+            <head>
+                <title>Farseer CLI - Error</title>
+                <style>
+                    * { margin: 0; padding: 0; box-sizing: border-box; }
+                    body {
+                        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                        background: #fafafa;
+                        min-height: 100vh;
+                        display: flex;
+                        align-items: center;
+                        justify-content: center;
+                    }
+                    .container {
+                        text-align: center;
+                        padding: 48px;
+                    }
+                    .error-icon {
+                        width: 80px;
+                        height: 80px;
+                        border-radius: 50%;
+                        background: #ef4444;
+                        display: flex;
+                        align-items: center;
+                        justify-content: center;
+                        margin: 0 auto 24px;
+                    }
+                    .error-icon svg {
+                        width: 40px;
+                        height: 40px;
+                        stroke: white;
+                        stroke-width: 3;
+                        fill: none;
+                    }
+                    h1 {
+                        color: #18181b;
+                        font-size: 24px;
+                        font-weight: 600;
+                        margin-bottom: 8px;
+                    }
+                    p {
+                        color: #71717a;
+                        font-size: 15px;
+                    }
+                </style>
+            </head>
+            <body>
+                <div class="container">
+                    <div class="error-icon">
+                        <svg viewBox="0 0 24 24">
+                            <line x1="18" y1="6" x2="6" y2="18"></line>
+                            <line x1="6" y1="6" x2="18" y2="18"></line>
+                        </svg>
+                    </div>
+                    <h1>${title}</h1>
+                    <p>${message}</p>
+                    <p style="margin-top: 16px;">You can close this window.</p>
+                </div>
+            </body>
+        </html>
+    `;
+}
+async function loginWithBrowser(realm = "master") {
+  const http = await import("http");
+  const crypto = await import("crypto");
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+  const KEYCLOAK_BASE = `https://login.farseer.io/auth/realms/${realm}/protocol/openid-connect`;
+  const CLIENT_ID = "auth";
+  const REDIRECT_PORT = 8787;
+  const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/callback`;
+  const codeVerifier = crypto.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
+  const state = crypto.randomBytes(16).toString("hex");
+  return new Promise((resolve) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url || "", `http://localhost:${REDIRECT_PORT}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(getErrorPage("Login Failed", `Error: ${error}`));
+          server.close();
+          resolve(null);
+          return;
+        }
+        if (!code || returnedState !== state) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(getErrorPage("Invalid Response", "Missing code or state mismatch."));
+          server.close();
+          resolve(null);
+          return;
+        }
+        try {
+          const tokenResponse = await fetch(`${KEYCLOAK_BASE}/token`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              grant_type: "authorization_code",
+              client_id: CLIENT_ID,
+              code,
+              redirect_uri: REDIRECT_URI,
+              code_verifier: codeVerifier
+            })
+          });
+          if (!tokenResponse.ok) {
+            throw new Error("Token exchange failed");
+          }
+          const data = await tokenResponse.json();
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+                        <html>
+                            <head>
+                                <title>Farseer CLI - Login</title>
+                                <style>
+                                    * { margin: 0; padding: 0; box-sizing: border-box; }
+                                    body {
+                                        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                                        background: #fafafa;
+                                        min-height: 100vh;
+                                        display: flex;
+                                        align-items: center;
+                                        justify-content: center;
+                                    }
+                                    .container {
+                                        text-align: center;
+                                        padding: 48px;
+                                    }
+                                    .checkmark {
+                                        width: 80px;
+                                        height: 80px;
+                                        border-radius: 50%;
+                                        background: #22c55e;
+                                        display: flex;
+                                        align-items: center;
+                                        justify-content: center;
+                                        margin: 0 auto 24px;
+                                        animation: scale-in 0.3s ease-out;
+                                    }
+                                    .checkmark svg {
+                                        width: 40px;
+                                        height: 40px;
+                                        stroke: white;
+                                        stroke-width: 3;
+                                        fill: none;
+                                        animation: draw 0.4s ease-out 0.2s forwards;
+                                        stroke-dasharray: 50;
+                                        stroke-dashoffset: 50;
+                                    }
+                                    @keyframes scale-in {
+                                        from { transform: scale(0); }
+                                        to { transform: scale(1); }
+                                    }
+                                    @keyframes draw {
+                                        to { stroke-dashoffset: 0; }
+                                    }
+                                    h1 {
+                                        color: #18181b;
+                                        font-size: 24px;
+                                        font-weight: 600;
+                                        margin-bottom: 8px;
+                                    }
+                                    p {
+                                        color: #71717a;
+                                        font-size: 15px;
+                                    }
+                                </style>
+                            </head>
+                            <body>
+                                <div class="container">
+                                    <div class="checkmark">
+                                        <svg viewBox="0 0 24 24">
+                                            <polyline points="20 6 9 17 4 12"></polyline>
+                                        </svg>
+                                    </div>
+                                    <h1>Login Successful</h1>
+                                    <p>You can close this window and return to the terminal.</p>
+                                </div>
+                            </body>
+                        </html>
+                    `);
+          server.close();
+          resolve({
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            expiresIn: data.expires_in
+          });
+        } catch {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(getErrorPage("Token Exchange Failed", "Could not complete login."));
+          server.close();
+          resolve(null);
+        }
+      }
+    });
+    server.listen(REDIRECT_PORT, async () => {
+      const authUrl = new URL(`${KEYCLOAK_BASE}/auth`);
+      authUrl.searchParams.set("client_id", CLIENT_ID);
+      authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+      authUrl.searchParams.set("response_type", "code");
+      authUrl.searchParams.set("scope", "openid offline_access");
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("code_challenge", codeChallenge);
+      authUrl.searchParams.set("code_challenge_method", "S256");
+      const url = authUrl.toString();
+      try {
+        if (process.platform === "darwin") {
+          await execAsync(`open "${url}"`);
+        } else if (process.platform === "win32") {
+          await execAsync(`start "${url}"`);
+        } else {
+          await execAsync(`xdg-open "${url}"`);
+        }
+      } catch {
+        console.log(`
+Open this URL in your browser:
+${url}
+`);
+      }
+    });
+    setTimeout(() => {
+      server.close();
+      resolve(null);
+    }, 5 * 60 * 1e3);
+  });
+}
+async function refreshAccessToken(refreshToken, realm = "master") {
+  const tokenUrl = `https://login.farseer.io/auth/realms/${realm}/protocol/openid-connect/token`;
+  try {
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: "auth",
+        refresh_token: refreshToken
+      })
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresIn: data.expires_in
+    };
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FarseerService,
+  loginWithBrowser,
+  loginWithPassword,
+  refreshAccessToken
+});
+//# sourceMappingURL=farseerService.js.map