skedyul 1.0.2 → 1.0.4

package/dist/cli/commands/invoke-remote.js

@@ -0,0 +1,322 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeRemoteCommand = invokeRemoteCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const auth_1 = require("../utils/auth");
+/**
+ * Simple MIME type lookup based on file extension.
+ */
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.pdf': 'application/pdf',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.txt': 'text/plain',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.csv': 'text/csv',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.zip': 'application/zip',
+        '.mp3': 'audio/mpeg',
+        '.mp4': 'video/mp4',
+        '.wav': 'audio/wav',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+/**
+ * Upload a local file to the platform and return its file ID.
+ */
+async function uploadLocalFile(filePath, serverUrl, token, appInstallationId) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+    }
+    const content = fs.readFileSync(absolutePath);
+    const fileName = path.basename(absolutePath);
+    const mimeType = getMimeType(absolutePath);
+    console.error(`Uploading file: ${fileName} (${mimeType}, ${content.length} bytes)...`);
+    const url = `${serverUrl}/api/cli/upload-file`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            appInstallationId,
+            content: content.toString('base64'),
+            name: fileName,
+            mimeType,
+        }),
+    });
+    const text = await response.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        if (text.startsWith('<!DOCTYPE') || text.startsWith('<html')) {
+            throw new Error(`Server returned HTML instead of JSON (status ${response.status}). ` +
+                `This usually means the API endpoint doesn't exist or there's a server error.`);
+        }
+        throw new Error(`Invalid response from server: ${text.substring(0, 200)}`);
+    }
+    if (!response.ok) {
+        const errorResponse = json;
+        throw new Error(errorResponse.error ?? `Upload failed: ${response.status}`);
+    }
+    const uploadResponse = json;
+    if (!uploadResponse.success || !uploadResponse.id) {
+        throw new Error(uploadResponse.error ?? 'Upload failed: no file ID returned');
+    }
+    console.error(`Uploaded: ${fileName} -> ${uploadResponse.id}`);
+    return uploadResponse.id;
+}
+/**
+ * Process upload templates in args object.
+ * Recursively scans all string values and replaces {{upload:/path/to/file}} patterns
+ * with the uploaded file ID.
+ */
+async function processUploadTemplates(args, serverUrl, token, appInstallationId) {
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value === 'string') {
+            const match = value.match(/^\{\{upload:(.+)\}\}$/);
+            if (match) {
+                const filePath = match[1];
+                const fileId = await uploadLocalFile(filePath, serverUrl, token, appInstallationId);
+                result[key] = fileId;
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        else if (Array.isArray(value)) {
+            result[key] = await Promise.all(value.map(async (item) => {
+                if (typeof item === 'string') {
+                    const match = item.match(/^\{\{upload:(.+)\}\}$/);
+                    if (match) {
+                        return await uploadLocalFile(match[1], serverUrl, token, appInstallationId);
+                    }
+                }
+                else if (item && typeof item === 'object') {
+                    return await processUploadTemplates(item, serverUrl, token, appInstallationId);
+                }
+                return item;
+            }));
+        }
+        else if (value && typeof value === 'object') {
+            result[key] = await processUploadTemplates(value, serverUrl, token, appInstallationId);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+async function callInvokeApi(serverUrl, token, body) {
+    const url = `${serverUrl}/api/cli/invoke-tool`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        if (text.startsWith('<!DOCTYPE') || text.startsWith('<html')) {
+            throw new Error(`Server returned HTML instead of JSON (status ${response.status}). ` +
+                `This usually means the API endpoint doesn't exist or there's a server error.`);
+        }
+        throw new Error(`Invalid response from server: ${text.substring(0, 200)}`);
+    }
+    if (!response.ok) {
+        const errorResponse = json;
+        let errorMessage = errorResponse.error ?? `API error: ${response.status}`;
+        if (errorResponse.availableTools && errorResponse.availableTools.length > 0) {
+            errorMessage += `\n\nAvailable tools:\n${errorResponse.availableTools.map(t => `  - ${t}`).join('\n')}`;
+        }
+        throw new Error(errorMessage);
+    }
+    return json;
+}
+function printHelp() {
+    console.log(`
+skedyul invoke - Invoke a tool on a hosted app version
+
+Usage:
+  skedyul invoke <tool-name> --appInstallationId <id> [options]
+
+Arguments:
+  <tool-name>              Name of the tool to invoke (e.g., 'parse_lab_report')
+
+Required Options:
+  --appInstallationId, -i  The app installation ID to invoke the tool on
+
+Optional Options:
+  --args, -a               JSON string of arguments to pass to the tool
+                           Supports {{upload:/path/to/file}} syntax for file uploads
+  --timeout, -t            Timeout in milliseconds (default: uses tool config)
+  --server                 Override the server URL
+  --help, -h               Show this help message
+
+File Upload Syntax:
+  Use {{upload:/path/to/file}} in any string field within --args to automatically
+  upload a local file and replace the template with the uploaded file ID.
+
+Examples:
+  # Invoke a tool with no arguments
+  skedyul invoke get_appointments --appInstallationId inst_abc123
+
+  # Invoke a tool with arguments
+  skedyul invoke parse_lab_report \\
+    --appInstallationId inst_abc123 \\
+    --args '{"file_id": "fl_existing_id"}'
+
+  # Invoke with file upload (uploads file and injects file_id)
+  skedyul invoke parse_lab_report \\
+    --appInstallationId inst_abc123 \\
+    --args '{"file_id": "{{upload:/path/to/report.pdf}}"}'
+
+  # Multiple file uploads in one command
+  skedyul invoke process_documents \\
+    --appInstallationId inst_abc123 \\
+    --args '{"doc": "{{upload:./doc.pdf}}", "image": "{{upload:./photo.jpg}}"}'
+
+  # Invoke with custom timeout (30 seconds)
+  skedyul invoke long_running_task \\
+    --appInstallationId inst_abc123 \\
+    --timeout 30000
+
+Note:
+  You must be logged in with 'skedyul auth login' and have access to the
+  workplace where the app is installed.
+`);
+}
+async function invokeRemoteCommand(args) {
+    const { flags, positional } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    const toolName = positional[0];
+    if (!toolName) {
+        console.error('Error: Tool name is required');
+        console.error("Run 'skedyul invoke --help' for usage information.");
+        process.exit(1);
+    }
+    const appInstallationId = (flags.appInstallationId || flags.i);
+    if (!appInstallationId) {
+        console.error('Error: --appInstallationId is required');
+        console.error("Run 'skedyul invoke --help' for usage information.");
+        process.exit(1);
+    }
+    let toolArgs = {};
+    const argsValue = flags.args || flags.a;
+    if (argsValue && typeof argsValue === 'string') {
+        try {
+            toolArgs = JSON.parse(argsValue);
+        }
+        catch {
+            console.error('Error: Invalid JSON in --args');
+            process.exit(1);
+        }
+    }
+    let timeout;
+    const timeoutValue = flags.timeout || flags.t;
+    if (timeoutValue) {
+        const parsed = parseInt(String(timeoutValue), 10);
+        if (isNaN(parsed) || parsed <= 0) {
+            console.error('Error: --timeout must be a positive number');
+            process.exit(1);
+        }
+        timeout = parsed;
+    }
+    const credentials = (0, auth_1.getCredentials)();
+    if (!credentials) {
+        console.error('Error: Not logged in.');
+        console.error("Run 'skedyul auth login' to authenticate first.");
+        process.exit(1);
+    }
+    const serverUrl = (0, auth_1.getServerUrl)(flags.server);
+    const activeProfile = (0, auth_1.getActiveProfileName)();
+    console.error(`Invoking tool: ${toolName}`);
+    console.error(`App Installation: ${appInstallationId}`);
+    console.error(`Server: ${serverUrl}`);
+    if (activeProfile) {
+        console.error(`Profile: ${activeProfile}`);
+    }
+    try {
+        toolArgs = await processUploadTemplates(toolArgs, serverUrl, credentials.token, appInstallationId);
+        const response = await callInvokeApi(serverUrl, credentials.token, {
+            appInstallationId,
+            toolName,
+            args: toolArgs,
+            ...(timeout !== undefined && { timeout }),
+        });
+        if (response.success) {
+            console.log((0, utils_1.formatJson)({ result: response.result }));
+        }
+        else {
+            console.error(`Error: ${response.error ?? 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const invoke_1 = require("./commands/invoke");
+const invoke_remote_1 = require("./commands/invoke-remote");
 const tools_1 = require("./commands/tools");
 const serve_1 = require("./commands/serve");
 const validate_1 = require("./commands/validate");
@@ -33,6 +34,7 @@ USAGE
 COMMANDS
   auth    Authenticate with Skedyul (login, logout, status)
   config  Manage global CLI configuration (ngrok, server URL)
+  invoke  Invoke a tool on a hosted app version
   dev     Development tools for building and testing apps locally
 
 GETTING STARTED
@@ -63,6 +65,7 @@ CONFIGURATION
 MORE HELP
   $ skedyul auth --help      Show authentication commands
   $ skedyul config --help    Show configuration commands
+  $ skedyul invoke --help    Show invoke command options
   $ skedyul dev --help       Show development commands
   $ skedyul <cmd> --help     Show help for specific command
 
@@ -165,6 +168,10 @@ async function main() {
         await (0, config_1.configCommand)(args.slice(1));
         return;
     }
+    if (command === 'invoke') {
+        await (0, invoke_remote_1.invokeRemoteCommand)(args.slice(1));
+        return;
+    }
     if (command !== 'dev') {
         console.error(`Unknown command: ${command}`);
         console.error(`Run 'skedyul --help' for usage information.`);

package/dist/cli/utils/auth.d.ts

@@ -1,18 +1,54 @@
-export interface StoredCredentials {
+export interface Profile {
+    serverUrl: string;
     token: string;
     userId: string;
     username: string;
     email: string;
-    serverUrl: string;
     expiresAt: string | null;
     createdAt: string;
 }
+export interface ProfilesFile {
+    profiles: Record<string, Profile>;
+}
 export interface AuthConfig {
+    activeProfile?: string;
     defaultServer: string;
     ngrokAuthtoken?: string;
 }
+/** @deprecated Use Profile instead - kept for migration */
+export interface StoredCredentials {
+    token: string;
+    userId: string;
+    username: string;
+    email: string;
+    serverUrl: string;
+    expiresAt: string | null;
+    createdAt: string;
+}
+/**
+ * Generate a sensible profile name from a server URL.
+ */
+export declare function generateProfileName(serverUrl: string): string;
+/**
+ * Ensure a profile name is unique by appending a number if needed.
+ */
+export declare function ensureUniqueProfileName(baseName: string, existingProfiles: Record<string, Profile>): string;
+export declare function getProfiles(): ProfilesFile;
+export declare function saveProfiles(profilesFile: ProfilesFile): void;
+export declare function getProfile(name: string): Profile | null;
+export declare function saveProfile(name: string, profile: Profile): void;
+export declare function deleteProfile(name: string): boolean;
+export declare function listProfiles(): Array<{
+    name: string;
+    profile: Profile;
+    isActive: boolean;
+    isExpired: boolean;
+}>;
+export declare function clearAllProfiles(): void;
+export declare function getActiveProfileName(): string | null;
+export declare function setActiveProfile(name: string): boolean;
 export declare function getCredentials(): StoredCredentials | null;
-export declare function saveCredentials(credentials: StoredCredentials): void;
+export declare function saveCredentials(credentials: StoredCredentials, profileName?: string): string;
 export declare function clearCredentials(): void;
 export declare function getConfig(): AuthConfig;
 export declare function saveConfig(config: AuthConfig): void;
@@ -25,7 +61,7 @@ export declare function getLocalConfig(): {
 };
 /**
  * Get the server URL to use.
- * Priority: CLI flag > local config > credentials > global config > default
+ * Priority: CLI flag > local config > active profile > global config > default
  */
 export declare function getServerUrl(override?: string): string;
 /**