farseer-cli 1.0.0

package/dist/services/farseerFactory.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Factory for creating Farseer API client based on available authentication
+ *
+ * Priority:
+ * 1. JWT token (from browser login) - try first
+ * 2. API key (from config) - fallback if JWT fails or unavailable
+ * 3. Prompt user to login - if nothing works
+ */
+/**
+ * Check if an error is an authentication error (401/403)
+ */
+export declare function isAuthError(error: unknown): boolean;
+/**
+ * Show a consistent "please login" message
+ */
+export declare function showLoginPrompt(tenant?: string): void;
+export interface RemoteFile {
+    name: string;
+    path: string;
+    reference: string;
+}
+export declare const DEFAULT_SCRIPT_EXTENSIONS: string[];
+import { AppArgument, AppListItem, RemoteApp, ModelExport } from './farseerApi';
+export interface IFarseerClient {
+    testConnection(): Promise<boolean>;
+    getFilesFolder(): Promise<{
+        id: number;
+        name: string;
+        type: string;
+    } | null>;
+    listFiles(folderPath?: string[]): Promise<RemoteFile[]>;
+    getFileContent(reference: string): Promise<string>;
+    getFileContentAsBuffer(reference: string): Promise<Buffer>;
+    createFile(content: string | Buffer, fileName: string, folderPath?: string[]): Promise<void>;
+    updateFile(reference: string, content: string | Buffer, fileName: string): Promise<void>;
+    deleteFile(reference: string): Promise<void>;
+    getFileByPath(filePath: string): Promise<RemoteFile | null>;
+    isTextFile(filename: string): boolean;
+    isBinaryFile(filename: string): boolean;
+    listApps(): Promise<AppListItem[]>;
+    getApp(referenceId: string): Promise<RemoteApp | null>;
+    getAppByName(name: string): Promise<RemoteApp | null>;
+    createApp(name: string): Promise<RemoteApp>;
+    updateApp(referenceId: string, update: {
+        name?: string;
+        description?: string;
+        expectedArguments?: AppArgument[];
+        mainScriptFileId?: string | null;
+        scriptFileIds?: string[];
+    }): Promise<RemoteApp>;
+    deleteApp(referenceId: string): Promise<void>;
+    getScriptFiles(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    exportModel(): Promise<ModelExport>;
+}
+export interface FarseerClientResult {
+    client: IFarseerClient;
+    authType: 'apiKey' | 'jwt';
+}
+/**
+ * Get a Farseer client for the given tenant.
+ * Tries JWT token first (supports apps), then falls back to API key.
+ *
+ * @param tenant - The tenant hostname (e.g., "omnicom" for omnicom.farseer.io)
+ * @param tenantId - Optional tenant ID for x-tenant-id header (e.g., "omnicom-reporting")
+ *                   Only used with JWT auth. Defaults to tenant if not specified.
+ */
+export declare function getFarseerClient(tenant: string, tenantId?: string): Promise<FarseerClientResult | null>;
+/**
+ * Check what authentication methods are available
+ */
+export declare function getAvailableAuth(tenant: string): {
+    hasApiKey: boolean;
+    hasJwt: boolean;
+    jwtValid: boolean;
+};
+/**
+ * Get a Farseer client with automatic fallback and connection testing.
+ * This is the recommended way to get a client for commands.
+ *
+ * Flow:
+ * 1. Try JWT if available and valid
+ * 2. If JWT fails or unavailable, try API key
+ * 3. If nothing works, return null (caller should show login prompt)
+ */
+export declare function getFarseerClientWithFallback(tenant: string, tenantId?: string): Promise<FarseerClientResult | null>;

package/dist/services/farseerFactory.js

@@ -0,0 +1,179 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var farseerFactory_exports = {};
+__export(farseerFactory_exports, {
+  DEFAULT_SCRIPT_EXTENSIONS: () => DEFAULT_SCRIPT_EXTENSIONS,
+  ensureFreshToken: () => ensureFreshToken,
+  getAvailableAuth: () => getAvailableAuth,
+  getFarseerClient: () => getFarseerClient,
+  getFarseerClientWithFallback: () => getFarseerClientWithFallback,
+  isAuthError: () => isAuthError,
+  showLoginPrompt: () => showLoginPrompt
+});
+module.exports = __toCommonJS(farseerFactory_exports);
+var import_farseerService = require("./farseerService");
+var import_farseerApi = require("./farseerApi");
+var import_configService = require("./configService");
+var import_farseerService2 = require("./farseerService");
+var import_logger = require("../utils/logger");
+function isAuthError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("401") || msg.includes("403") || msg.includes("unauthorized") || msg.includes("forbidden");
+  }
+  return false;
+}
+function showLoginPrompt(tenant) {
+  import_logger.logger.error("Authentication required.");
+  if (tenant) {
+    import_logger.logger.dim(`No valid credentials found for tenant "${tenant}".`);
+  }
+  import_logger.logger.info('Run "farseer login" to authenticate via browser.');
+  import_logger.logger.dim('Or use "farseer config set <tenant> --api-key <key>" for API key auth.');
+}
+const DEFAULT_SCRIPT_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
+async function getFarseerClient(organisation, tenant) {
+  const auth = (0, import_configService.getUserAuth)();
+  if (auth) {
+    let accessToken = auth.accessToken;
+    if (!(0, import_configService.isUserAuthValid)()) {
+      import_logger.logger.dim("Token expired, refreshing...");
+      const refreshed = await (0, import_farseerService2.refreshAccessToken)(auth.refreshToken, auth.realm || "master");
+      if (!refreshed) {
+        import_logger.logger.warning("Could not refresh token. Please login again with: farseer login");
+      } else {
+        (0, import_configService.setUserAuth)({
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken,
+          expiresAt: new Date(Date.now() + refreshed.expiresIn * 1e3).toISOString(),
+          realm: auth.realm
+        });
+        accessToken = refreshed.accessToken;
+        import_logger.logger.dim("Token refreshed");
+      }
+    }
+    if ((0, import_configService.isUserAuthValid)()) {
+      return {
+        client: new import_farseerApi.FarseerApi(accessToken, organisation, tenant),
+        authType: "jwt"
+      };
+    }
+  }
+  const credential = (0, import_configService.getCredential)(tenant);
+  if (credential) {
+    return {
+      client: new import_farseerService.FarseerService(credential),
+      authType: "apiKey"
+    };
+  }
+  return null;
+}
+function getAvailableAuth(tenant) {
+  const credential = (0, import_configService.getCredential)(tenant);
+  const auth = (0, import_configService.getUserAuth)();
+  return {
+    hasApiKey: !!credential,
+    hasJwt: !!auth,
+    jwtValid: (0, import_configService.isUserAuthValid)()
+  };
+}
+async function getFarseerClientWithFallback(organisation, tenant) {
+  const auth = (0, import_configService.getUserAuth)();
+  const credential = (0, import_configService.getCredential)(tenant);
+  if (auth) {
+    let accessToken = auth.accessToken;
+    if (!(0, import_configService.isUserAuthValid)()) {
+      import_logger.logger.dim("Token expired, refreshing...");
+      const refreshed = await (0, import_farseerService2.refreshAccessToken)(auth.refreshToken, auth.realm || "master");
+      if (refreshed) {
+        (0, import_configService.setUserAuth)({
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken,
+          expiresAt: new Date(Date.now() + refreshed.expiresIn * 1e3).toISOString(),
+          realm: auth.realm
+        });
+        accessToken = refreshed.accessToken;
+        import_logger.logger.dim("Token refreshed");
+      }
+    }
+    if ((0, import_configService.isUserAuthValid)()) {
+      const jwtClient = new import_farseerApi.FarseerApi(accessToken, organisation, tenant);
+      try {
+        const connected = await jwtClient.testConnection();
+        if (connected) {
+          return { client: jwtClient, authType: "jwt" };
+        }
+      } catch (error) {
+        import_logger.logger.dim("JWT auth failed for this tenant, trying API key...");
+      }
+    }
+  }
+  if (credential) {
+    const apiKeyClient = new import_farseerService.FarseerService(credential);
+    try {
+      const connected = await apiKeyClient.testConnection();
+      if (connected) {
+        return { client: apiKeyClient, authType: "apiKey" };
+      }
+    } catch {
+      import_logger.logger.dim("API key auth failed.");
+    }
+  }
+  return null;
+}
+async function ensureFreshToken(client) {
+  const auth = (0, import_configService.getUserAuth)();
+  if (!auth) {
+    return false;
+  }
+  const expiresAt = new Date(auth.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  const bufferMs = 30 * 1e3;
+  if (expiresAt.getTime() - now.getTime() > bufferMs) {
+    return false;
+  }
+  import_logger.logger.dim("Refreshing token before operation...");
+  const refreshed = await (0, import_farseerService2.refreshAccessToken)(auth.refreshToken, auth.realm || "master");
+  if (!refreshed) {
+    import_logger.logger.warning("Could not refresh token.");
+    return false;
+  }
+  (0, import_configService.setUserAuth)({
+    accessToken: refreshed.accessToken,
+    refreshToken: refreshed.refreshToken,
+    expiresAt: new Date(Date.now() + refreshed.expiresIn * 1e3).toISOString(),
+    realm: auth.realm
+  });
+  if (client.updateAccessToken) {
+    client.updateAccessToken(refreshed.accessToken);
+    import_logger.logger.dim("Token refreshed");
+    return true;
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SCRIPT_EXTENSIONS,
+  ensureFreshToken,
+  getAvailableAuth,
+  getFarseerClient,
+  getFarseerClientWithFallback,
+  isAuthError,
+  showLoginPrompt
+});
+//# sourceMappingURL=farseerFactory.js.map

package/dist/services/farseerFactory.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/farseerFactory.ts"],
+  "sourcesContent": ["/**\n * Factory for creating Farseer API client based on available authentication\n *\n * Priority:\n * 1. JWT token (from browser login) - try first\n * 2. API key (from config) - fallback if JWT fails or unavailable\n * 3. Prompt user to login - if nothing works\n */\n\nimport { FarseerService } from './farseerService';\nimport { FarseerApi } from './farseerApi';\nimport { getCredential, getUserAuth, isUserAuthValid, setUserAuth } from './configService';\nimport { refreshAccessToken } from './farseerService';\nimport { logger } from '../utils/logger';\n\n/**\n * Check if an error is an authentication error (401/403)\n */\nexport function isAuthError(error: unknown): boolean {\n    if (error instanceof Error) {\n        const msg = error.message.toLowerCase();\n        return msg.includes('401') || msg.includes('403') || msg.includes('unauthorized') || msg.includes('forbidden');\n    }\n    return false;\n}\n\n/**\n * Show a consistent \"please login\" message\n */\nexport function showLoginPrompt(tenant?: string): void {\n    logger.error('Authentication required.');\n    if (tenant) {\n        logger.dim(`No valid credentials found for tenant \"${tenant}\".`);\n    }\n    logger.info('Run \"farseer login\" to authenticate via browser.');\n    logger.dim('Or use \"farseer config set <tenant> --api-key <key>\" for API key auth.');\n}\n\nexport interface FileMetadata {\n    uploadTime?: string;       // ISO timestamp\n    uploader?: {\n        id: number;\n        email: string;\n        firstName: string;\n        lastName: string;\n    };\n    size?: number;\n}\n\nexport interface RemoteFile {\n    name: string;\n    path: string;\n    reference: string;\n    metadata?: FileMetadata;\n}\n\n// Default file extensions to sync (scripts only)\nexport const DEFAULT_SCRIPT_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs'];\n\nimport { AppArgument, AppListItem, RemoteApp, ModelExport } from './farseerApi';\n\n// Common interface that both FarseerService and FarseerApi implement\nexport interface IFarseerClient {\n    testConnection(): Promise<boolean>;\n    getFilesFolder(): Promise<{ id: number; name: string; type: string } | null>;\n    listFiles(folderPath?: string[]): Promise<RemoteFile[]>;\n    getFileContent(reference: string): Promise<string>;\n    getFileContentAsBuffer(reference: string): Promise<Buffer>;\n    createFile(content: string | Buffer, fileName: string, folderPath?: string[]): Promise<void>;\n    updateFile(reference: string, content: string | Buffer, fileName: string): Promise<void>;\n    deleteFile(reference: string): Promise<void>;\n    getFileByPath(filePath: string): Promise<RemoteFile | null>;\n    getFileMetadata(reference: string): Promise<FileMetadata | null>;\n    isTextFile(filename: string): boolean;\n    isBinaryFile(filename: string): boolean;\n    // Apps API methods\n    listApps(): Promise<AppListItem[]>;\n    getApp(referenceId: string): Promise<RemoteApp | null>;\n    getAppByName(name: string): Promise<RemoteApp | null>;\n    createApp(name: string): Promise<RemoteApp>;\n    updateApp(referenceId: string, update: {\n        name?: string;\n        description?: string;\n        expectedArguments?: AppArgument[];\n        mainScriptFileId?: string | null;\n        scriptFileIds?: string[];\n    }): Promise<RemoteApp>;\n    deleteApp(referenceId: string): Promise<void>;\n    getScriptFiles(): Promise<{ id: string; name: string }[]>;\n    // Model export\n    exportModel(): Promise<ModelExport>;\n    // Token management (optional - only FarseerApi implements this)\n    updateAccessToken?(newToken: string): void;\n}\n\nexport interface FarseerClientResult {\n    client: IFarseerClient;\n    authType: 'apiKey' | 'jwt';\n}\n\n/**\n * Get a Farseer client for the given organisation and tenant.\n * Tries JWT token first (supports apps), then falls back to API key.\n *\n * @param organisation - The organisation hostname (e.g., \"jgl\" for jgl.farseer.io)\n * @param tenant - Tenant name for X-TENANT-ID header (e.g., \"tt-hotels-hr-dev\")\n */\nexport async function getFarseerClient(organisation: string, tenant: string): Promise<FarseerClientResult | null> {\n    // 1. Try JWT token from browser login first (supports apps sync)\n    const auth = getUserAuth();\n    if (auth) {\n        // Check if token needs refresh\n        let accessToken = auth.accessToken;\n        if (!isUserAuthValid()) {\n            logger.dim('Token expired, refreshing...');\n            const refreshed = await refreshAccessToken(auth.refreshToken, auth.realm || 'master');\n            if (!refreshed) {\n                logger.warning('Could not refresh token. Please login again with: farseer login');\n                // Fall through to API key\n            } else {\n                // Save refreshed token\n                setUserAuth({\n                    accessToken: refreshed.accessToken,\n                    refreshToken: refreshed.refreshToken,\n                    expiresAt: new Date(Date.now() + refreshed.expiresIn * 1000).toISOString(),\n                    realm: auth.realm,\n                });\n                accessToken = refreshed.accessToken;\n                logger.dim('Token refreshed');\n            }\n        }\n\n        if (isUserAuthValid()) {\n            return {\n                client: new FarseerApi(accessToken, organisation, tenant),\n                authType: 'jwt',\n            };\n        }\n    }\n\n    // 2. Fall back to API key config\n    const credential = getCredential(tenant);\n    if (credential) {\n        return {\n            client: new FarseerService(credential),\n            authType: 'apiKey',\n        };\n    }\n\n    return null;\n}\n\n/**\n * Check what authentication methods are available\n */\nexport function getAvailableAuth(tenant: string): {\n    hasApiKey: boolean;\n    hasJwt: boolean;\n    jwtValid: boolean;\n} {\n    const credential = getCredential(tenant);\n    const auth = getUserAuth();\n\n    return {\n        hasApiKey: !!credential,\n        hasJwt: !!auth,\n        jwtValid: isUserAuthValid(),\n    };\n}\n\n/**\n * Get a Farseer client with automatic fallback and connection testing.\n * This is the recommended way to get a client for commands.\n *\n * Flow:\n * 1. Try JWT if available and valid\n * 2. If JWT fails or unavailable, try API key\n * 3. If nothing works, return null (caller should show login prompt)\n *\n * @param organisation - The organisation hostname (e.g., \"jgl\" for jgl.farseer.io)\n * @param tenant - Tenant name for X-TENANT-ID header (e.g., \"tt-hotels-hr-dev\")\n */\nexport async function getFarseerClientWithFallback(\n    organisation: string,\n    tenant: string\n): Promise<FarseerClientResult | null> {\n    const auth = getUserAuth();\n    const credential = getCredential(tenant);\n\n    // 1. Try JWT token first\n    if (auth) {\n        let accessToken = auth.accessToken;\n\n        // Refresh token if needed\n        if (!isUserAuthValid()) {\n            logger.dim('Token expired, refreshing...');\n            const refreshed = await refreshAccessToken(auth.refreshToken, auth.realm || 'master');\n            if (refreshed) {\n                setUserAuth({\n                    accessToken: refreshed.accessToken,\n                    refreshToken: refreshed.refreshToken,\n                    expiresAt: new Date(Date.now() + refreshed.expiresIn * 1000).toISOString(),\n                    realm: auth.realm,\n                });\n                accessToken = refreshed.accessToken;\n                logger.dim('Token refreshed');\n            }\n        }\n\n        if (isUserAuthValid()) {\n            const jwtClient = new FarseerApi(accessToken, organisation, tenant);\n\n            // Test JWT connection\n            try {\n                const connected = await jwtClient.testConnection();\n                if (connected) {\n                    return { client: jwtClient, authType: 'jwt' };\n                }\n            } catch (error) {\n                // JWT failed, will try API key\n                logger.dim('JWT auth failed for this tenant, trying API key...');\n            }\n        }\n    }\n\n    // 2. Try API key\n    if (credential) {\n        const apiKeyClient = new FarseerService(credential);\n\n        try {\n            const connected = await apiKeyClient.testConnection();\n            if (connected) {\n                return { client: apiKeyClient, authType: 'apiKey' };\n            }\n        } catch {\n            // API key also failed\n            logger.dim('API key auth failed.');\n        }\n    }\n\n    // 3. Nothing worked\n    return null;\n}\n\n/**\n * Ensure the token is fresh and update the client if needed.\n * Call this before long-running operations to avoid token expiration.\n *\n * @returns true if token was refreshed, false if no refresh needed or API key auth\n */\nexport async function ensureFreshToken(client: IFarseerClient): Promise<boolean> {\n    const auth = getUserAuth();\n    if (!auth) {\n        return false; // No JWT auth, probably using API key\n    }\n\n    // Check if token needs refresh (give 30 second buffer)\n    const expiresAt = new Date(auth.expiresAt);\n    const now = new Date();\n    const bufferMs = 30 * 1000; // 30 seconds\n\n    if (expiresAt.getTime() - now.getTime() > bufferMs) {\n        return false; // Token is still fresh enough\n    }\n\n    // Refresh the token\n    logger.dim('Refreshing token before operation...');\n    const refreshed = await refreshAccessToken(auth.refreshToken, auth.realm || 'master');\n\n    if (!refreshed) {\n        logger.warning('Could not refresh token.');\n        return false;\n    }\n\n    // Save the new token\n    setUserAuth({\n        accessToken: refreshed.accessToken,\n        refreshToken: refreshed.refreshToken,\n        expiresAt: new Date(Date.now() + refreshed.expiresIn * 1000).toISOString(),\n        realm: auth.realm,\n    });\n\n    // Update the client's token if it supports it\n    if (client.updateAccessToken) {\n        client.updateAccessToken(refreshed.accessToken);\n        logger.dim('Token refreshed');\n        return true;\n    }\n\n    return false;\n}\n"],
+  "mappings": "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",
+  "names": ["import_farseerService"]
+}

package/dist/services/farseerService.d.ts

@@ -0,0 +1,96 @@
+import { ApiKeyCredential } from './configService';
+import { AppArgument, AppListItem, RemoteApp } from './farseerApi';
+export interface RemoteFile {
+    name: string;
+    path: string;
+    reference: string;
+    content?: string;
+}
+export interface FolderItem {
+    id: number;
+    name: string;
+    type: string;
+    reference?: string;
+}
+export declare class FarseerService {
+    private client;
+    private credential;
+    constructor(credential: ApiKeyCredential);
+    static fromUserAuth(tenant: string, basePath: string): FarseerService | null;
+    testConnection(): Promise<boolean>;
+    getFilesFolder(): Promise<FolderItem | null>;
+    listFiles(folderPath?: string[]): Promise<RemoteFile[]>;
+    getFileContent(reference: string): Promise<string>;
+    createFile(content: string | Buffer, fileName: string, folderPath?: string[]): Promise<void>;
+    updateFile(reference: string, content: string | Buffer, fileName: string): Promise<void>;
+    deleteFile(reference: string): Promise<void>;
+    ensureFolderPath(folderPath: string[]): Promise<void>;
+    getFileByPath(filePath: string): Promise<RemoteFile | null>;
+    getFileContentAsBuffer(reference: string): Promise<Buffer>;
+    isTextFile(filename: string): boolean;
+    isBinaryFile(filename: string): boolean;
+    /**
+     * List all apps (Remote Jobs) on the tenant
+     */
+    listApps(): Promise<AppListItem[]>;
+    /**
+     * Get app details by reference ID
+     */
+    getApp(referenceId: string): Promise<RemoteApp | null>;
+    /**
+     * Get app by name
+     */
+    getAppByName(name: string): Promise<RemoteApp | null>;
+    /**
+     * Create a new app
+     */
+    createApp(name: string): Promise<RemoteApp>;
+    /**
+     * Update an app
+     */
+    updateApp(referenceId: string, update: {
+        name?: string;
+        description?: string;
+        expectedArguments?: AppArgument[];
+        mainScriptFileId?: string | null;
+        scriptFileIds?: string[];
+    }): Promise<RemoteApp>;
+    /**
+     * Delete an app
+     */
+    deleteApp(referenceId: string): Promise<void>;
+    /**
+     * Get script files available for apps
+     */
+    getScriptFiles(): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    /**
+     * Export the entire model structure
+     */
+    exportModel(): Promise<import('./farseerApi').ModelExport>;
+    /**
+     * Get the Apps folder ID
+     */
+    private getAppsFolderId;
+    /**
+     * Make a direct API request (for endpoints not in farseer-client)
+     */
+    private apiRequest;
+}
+export declare function loginWithPassword(email: string, password: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+} | null>;
+export declare function loginWithBrowser(): Promise<{
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+} | null>;
+export declare function refreshAccessToken(refreshToken: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+} | null>;