@simonfestl/husky-cli 0.9.3 → 0.9.6

package/dist/commands/services.js

@@ -0,0 +1,381 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+// Helper: Ensure API is configured
+function ensureConfig() {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    return { apiUrl: config.apiUrl, apiKey: config.apiKey };
+}
+// Helper: Make API request
+async function fetchAPI(apiUrl, apiKey, path, options = {}) {
+    const response = await fetch(`${apiUrl}${path}`, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            ...(apiKey ? { "x-api-key": apiKey } : {}),
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API Error: ${response.status} - ${error}`);
+    }
+    return response.json();
+}
+export const servicesCommand = new Command("services")
+    .description("Manage Agent Services (Agentic Workflow Platform)");
+// husky services list
+servicesCommand
+    .command("list")
+    .description("List all agent services")
+    .option("--project <id>", "Filter by project ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const params = new URLSearchParams();
+        if (options.project)
+            params.set("projectId", options.project);
+        const queryString = params.toString();
+        const path = queryString ? `/api/services?${queryString}` : "/api/services";
+        const services = await fetchAPI(config.apiUrl, config.apiKey, path);
+        if (options.json) {
+            console.log(JSON.stringify(services, null, 2));
+            return;
+        }
+        if (services.length === 0) {
+            console.log("No services found.");
+            return;
+        }
+        console.log("\n  Agent Services");
+        console.log("  " + "─".repeat(80));
+        for (const s of services) {
+            const statusIcon = {
+                building: "🔨",
+                deployed: "📦",
+                running: "✅",
+                failed: "❌",
+                disabled: "⏸️",
+            };
+            console.log(`  ${statusIcon[s.status] || "❓"} ${s.name} (${s.type})`);
+            console.log(`     ID: ${s.id}`);
+            console.log(`     Status: ${s.status}`);
+            if (s.schedule)
+                console.log(`     Schedule: ${s.schedule}`);
+            if (s.cloudRunUrl)
+                console.log(`     URL: ${s.cloudRunUrl}`);
+            console.log(`     Runs: ${s.runCount} (${s.successCount} success, ${s.failureCount} failed)`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services get <id>
+servicesCommand
+    .command("get <id>")
+    .description("Get service details")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`);
+        if (options.json) {
+            console.log(JSON.stringify(service, null, 2));
+            return;
+        }
+        console.log(`\n  Service: ${service.name}`);
+        console.log("  " + "─".repeat(50));
+        console.log(`  ID:          ${service.id}`);
+        console.log(`  Type:        ${service.type}`);
+        console.log(`  Status:      ${service.status}`);
+        if (service.description)
+            console.log(`  Description: ${service.description}`);
+        if (service.schedule)
+            console.log(`  Schedule:    ${service.schedule}`);
+        if (service.cloudRunUrl)
+            console.log(`  URL:         ${service.cloudRunUrl}`);
+        if (service.dockerImage)
+            console.log(`  Image:       ${service.dockerImage}`);
+        console.log(`  Runs:        ${service.runCount} total`);
+        console.log(`  Success:     ${service.successCount}`);
+        console.log(`  Failures:    ${service.failureCount}`);
+        if (service.avgDurationMs)
+            console.log(`  Avg Duration: ${service.avgDurationMs}ms`);
+        if (service.lastError)
+            console.log(`  Last Error:  ${service.lastError}`);
+        console.log(`  Created:     ${new Date(service.createdAt).toLocaleString()}`);
+        console.log(`  Updated:     ${new Date(service.updatedAt).toLocaleString()}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services create <name>
+servicesCommand
+    .command("create <name>")
+    .description("Create a new agent service")
+    .option("-t, --type <type>", "Service type (cloud-run, cloud-function, scheduled-job)", "cloud-run")
+    .option("-d, --description <desc>", "Service description")
+    .option("-s, --schedule <cron>", 'Cron schedule (e.g., "0 6 * * *")')
+    .option("--project <id>", "Link to project")
+    .option("--repo <url>", "Source repository URL")
+    .option("--path <path>", "Source path in repository")
+    .action(async (name, options) => {
+    const config = ensureConfig();
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, "/api/services", {
+            method: "POST",
+            body: JSON.stringify({
+                name,
+                type: options.type,
+                description: options.description,
+                schedule: options.schedule,
+                projectId: options.project,
+                sourceRepo: options.repo,
+                sourcePath: options.path,
+            }),
+        });
+        console.log(`✓ Created service: ${service.name} (${service.id})`);
+        console.log(`  Type: ${service.type}`);
+        console.log(`  Status: ${service.status}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services update <id>
+servicesCommand
+    .command("update <id>")
+    .description("Update a service")
+    .option("-d, --description <desc>", "Update description")
+    .option("-s, --schedule <cron>", "Update schedule")
+    .option("--status <status>", "Update status")
+    .option("--url <url>", "Set Cloud Run URL")
+    .option("--image <image>", "Set Docker image")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    const updates = {};
+    if (options.description)
+        updates.description = options.description;
+    if (options.schedule)
+        updates.schedule = options.schedule;
+    if (options.status)
+        updates.status = options.status;
+    if (options.url)
+        updates.cloudRunUrl = options.url;
+    if (options.image)
+        updates.dockerImage = options.image;
+    if (Object.keys(updates).length === 0) {
+        console.log("No updates specified. Use --help for available options.");
+        return;
+    }
+    try {
+        const service = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(updates),
+        });
+        console.log(`✓ Updated service: ${service.name}`);
+        const changedFields = Object.keys(updates).join(", ");
+        console.log(`  Changed: ${changedFields}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services delete <id>
+servicesCommand
+    .command("delete <id>")
+    .description("Delete a service")
+    .option("-f, --force", "Skip confirmation")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    if (!options.force) {
+        console.log("Use --force to confirm deletion.");
+        return;
+    }
+    try {
+        await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}`, { method: "DELETE" });
+        console.log(`✓ Deleted service: ${id}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services health
+servicesCommand
+    .command("health")
+    .description("Check health of all services")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = ensureConfig();
+    try {
+        const services = await fetchAPI(config.apiUrl, config.apiKey, "/api/services");
+        if (options.json) {
+            const healthData = services
+                .filter((s) => s.status !== "disabled")
+                .map((s) => ({
+                id: s.id,
+                name: s.name,
+                healthStatus: s.healthStatus || "unknown",
+                status: s.status,
+                lastError: s.lastError,
+            }));
+            console.log(JSON.stringify(healthData, null, 2));
+            return;
+        }
+        console.log("\n  Service Health");
+        console.log("  " + "─".repeat(50));
+        let healthy = 0;
+        let unhealthy = 0;
+        let unknown = 0;
+        for (const s of services) {
+            if (s.status === "disabled")
+                continue;
+            const icon = s.healthStatus === "healthy"
+                ? "✅"
+                : s.healthStatus === "unhealthy"
+                    ? "❌"
+                    : "❓";
+            console.log(`  ${icon} ${s.name}: ${s.healthStatus || "unknown"}`);
+            if (s.lastError && s.healthStatus === "unhealthy") {
+                console.log(`     Last Error: ${s.lastError}`);
+            }
+            if (s.healthStatus === "healthy")
+                healthy++;
+            else if (s.healthStatus === "unhealthy")
+                unhealthy++;
+            else
+                unknown++;
+        }
+        console.log("");
+        console.log(`  Summary: ${healthy} healthy, ${unhealthy} unhealthy, ${unknown} unknown`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services run <id>
+servicesCommand
+    .command("run <id>")
+    .description("Trigger a service run")
+    .option("--input <json>", "Input data as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    let inputData = {};
+    if (options.input) {
+        try {
+            inputData = JSON.parse(options.input);
+        }
+        catch {
+            console.error("Error: --input must be valid JSON");
+            process.exit(1);
+        }
+    }
+    try {
+        const result = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/run`, {
+            method: "POST",
+            body: JSON.stringify({ input: inputData }),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`✓ Service run triggered: ${id}`);
+        if (result.runId)
+            console.log(`  Run ID: ${result.runId}`);
+        if (result.status)
+            console.log(`  Status: ${result.status}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services logs <id>
+servicesCommand
+    .command("logs <id>")
+    .description("View service logs")
+    .option("-n, --lines <num>", "Number of log lines", "50")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const logs = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/logs?limit=${options.lines}`);
+        if (options.json) {
+            console.log(JSON.stringify(logs, null, 2));
+            return;
+        }
+        if (!logs.entries || logs.entries.length === 0) {
+            console.log(`No logs found for service ${id}`);
+            return;
+        }
+        console.log(`\n  Logs for service: ${id}`);
+        console.log("  " + "─".repeat(70));
+        for (const entry of logs.entries) {
+            const timestamp = new Date(entry.timestamp).toLocaleString();
+            const level = entry.level?.toUpperCase() || "INFO";
+            console.log(`  [${timestamp}] ${level}: ${entry.message}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// husky services runs <id>
+servicesCommand
+    .command("runs <id>")
+    .description("List recent runs for a service")
+    .option("-n, --limit <num>", "Number of runs to show", "10")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    const config = ensureConfig();
+    try {
+        const runs = await fetchAPI(config.apiUrl, config.apiKey, `/api/services/${id}/runs?limit=${options.limit}`);
+        if (options.json) {
+            console.log(JSON.stringify(runs, null, 2));
+            return;
+        }
+        if (!runs || runs.length === 0) {
+            console.log(`No runs found for service ${id}`);
+            return;
+        }
+        console.log(`\n  Recent Runs for service: ${id}`);
+        console.log("  " + "─".repeat(70));
+        for (const run of runs) {
+            const statusIcon = run.status === "success"
+                ? "✅"
+                : run.status === "failed"
+                    ? "❌"
+                    : run.status === "running"
+                        ? "▶"
+                        : "⏸️";
+            const timestamp = new Date(run.startedAt).toLocaleString();
+            const duration = run.durationMs ? `${run.durationMs}ms` : "—";
+            console.log(`  ${statusIcon} ${run.id.slice(0, 12)} │ ${timestamp} │ ${duration} │ ${run.status}`);
+            if (run.error) {
+                console.log(`     Error: ${run.error}`);
+            }
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});

package/dist/commands/vm.js

@@ -1,8 +1,10 @@
 import { Command } from "commander";
 import { getConfig } from "./config.js";
 import * as readline from "readline";
-export const vmCommand = new Command("vm")
-    .description("Manage VM sessions");
+import * as fs from "fs";
+import * as path from "path";
+import { DEFAULT_AGENT_CONFIGS, generateStartupScript, listDefaultAgentTypes, getDefaultAgentConfig, } from "../lib/agent-templates.js";
+export const vmCommand = new Command("vm").description("Manage VM sessions");
 // Helper: Ensure API is configured
 function ensureConfig() {
     const config = getConfig();
@@ -12,6 +14,50 @@ function ensureConfig() {
     }
     return config;
 }
+async function fetchAgentTypes() {
+    const config = getConfig();
+    if (!config.apiUrl)
+        return null;
+    try {
+        const res = await fetch(`${config.apiUrl}/api/agent-types`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchAgentTypeBySlug(slug) {
+    const config = getConfig();
+    if (!config.apiUrl)
+        return null;
+    try {
+        const res = await fetch(`${config.apiUrl}/api/agent-types?slug=${slug}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function getAgentTypeConfig(slug) {
+    const apiType = await fetchAgentTypeBySlug(slug);
+    if (apiType) {
+        return { config: apiType.agentConfig, name: apiType.name };
+    }
+    const defaultConfig = getDefaultAgentConfig(slug);
+    if (defaultConfig) {
+        const name = slug.charAt(0).toUpperCase() + slug.slice(1) + " Agent";
+        return { config: defaultConfig, name };
+    }
+    return null;
+}
 // Helper: Prompt for confirmation
 async function confirm(message) {
     const rl = readline.createInterface({
@@ -71,19 +117,40 @@ vmCommand
     .command("create <name>")
     .description("Create a new VM session")
     .option("-p, --prompt <prompt>", "Initial prompt for the agent")
-    .option("--agent <agent>", "Agent type (claude-code, gemini-cli, aider, custom)", "claude-code")
+    .option("--agent <agent>", "Agent type (claude-code, gemini-cli, aider, custom)", "gemini-cli")
+    .option("-t, --type <type>", "Business agent type (support, accounting, marketing, research)")
     .option("--config <configId>", "VM config to use")
     .option("--project <projectId>", "Link to project")
     .option("--task <taskId>", "Link to task")
     .option("--repo <repoUrl>", "Git repository URL")
     .option("--branch <branch>", "Git branch to use")
     .option("--machine-type <machineType>", "GCP machine type", "e2-medium")
-    .option("--zone <zone>", "GCP zone", "us-central1-a")
+    .option("--zone <zone>", "GCP zone", "europe-west1-b")
     .option("--json", "Output as JSON")
     .action(async (name, options) => {
     const config = ensureConfig();
+    const validBusinessTypes = [
+        "support",
+        "accounting",
+        "marketing",
+        "research",
+    ];
+    if (options.type && !validBusinessTypes.includes(options.type)) {
+        console.error(`Error: Invalid business agent type '${options.type}'`);
+        console.error(`Valid types: ${validBusinessTypes.join(", ")}`);
+        process.exit(1);
+    }
+    if (options.type && !options.prompt) {
+        const defaultPrompts = {
+            support: "Du bist ein Support Agent. Starte mit /shift-start um die Schicht zu beginnen.",
+            accounting: "Du bist ein Accounting Agent. Pruefe /inbox fuer neue Belege.",
+            marketing: "Du bist ein Marketing Agent. Pruefe /campaigns fuer aktuelle Kampagnen.",
+            research: "Du bist ein Research Agent. Pruefe /youtube fuer neue Videos zu analysieren.",
+        };
+        options.prompt = defaultPrompts[options.type] || "Agent bereit.";
+    }
     if (!options.prompt) {
-        console.error("Error: --prompt is required");
+        console.error("Error: --prompt is required (or use --type for default prompt)");
         process.exit(1);
     }
     try {
@@ -97,6 +164,7 @@ vmCommand
                 name,
                 prompt: options.prompt,
                 agentType: options.agent,
+                businessAgentType: options.type,
                 taskId: options.task,
                 workflowId: options.project,
                 repoUrl: options.repo,
@@ -118,9 +186,16 @@ vmCommand
             console.log(`Created VM session: ${session.name}`);
             console.log(`  ID:       ${session.id}`);
             console.log(`  Agent:    ${session.agentType}`);
+            if (session.businessAgentType) {
+                console.log(`  Type:     ${session.businessAgentType}`);
+            }
             console.log(`  Status:   ${formatStatus(session.vmStatus)}`);
             console.log(`  VM Name:  ${session.vmName}`);
+            console.log(`  Zone:     ${options.zone}`);
             console.log(`\nTo start the VM, run: husky vm start ${session.id}`);
+            if (session.businessAgentType) {
+                console.log(`\nAfter VM is ready, the ${session.businessAgentType} agent will be auto-configured.`);
+            }
         }
     }
     catch (error) {
@@ -523,6 +598,150 @@ vmCommand
         process.exit(1);
     }
 });
+vmCommand
+    .command("types")
+    .description("List available business agent types")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const apiTypes = await fetchAgentTypes();
+    if (apiTypes && apiTypes.length > 0) {
+        if (options.json) {
+            console.log(JSON.stringify(apiTypes, null, 2));
+            return;
+        }
+        console.log("\n  Available Agent Types (from API)");
+        console.log("  " + "-".repeat(70));
+        for (const type of apiTypes) {
+            console.log(`\n  ${type.slug.toUpperCase()} - ${type.name}`);
+            console.log(`    ${type.description}`);
+            console.log(`    Directories: ${type.agentConfig.directories.slice(0, 3).join(", ")}...`);
+        }
+    }
+    else {
+        const types = listDefaultAgentTypes();
+        if (options.json) {
+            console.log(JSON.stringify(DEFAULT_AGENT_CONFIGS, null, 2));
+            return;
+        }
+        console.log("\n  Available Agent Types (defaults)");
+        console.log("  " + "-".repeat(70));
+        for (const type of types) {
+            const config = DEFAULT_AGENT_CONFIGS[type];
+            console.log(`\n  ${type.toUpperCase()}`);
+            console.log(`    Default prompt: ${config.defaultPrompt}`);
+            console.log(`    Directories: ${config.directories.slice(0, 3).join(", ")}...`);
+        }
+    }
+    console.log("\n  Usage:");
+    console.log("    husky vm create my-agent --type support");
+    console.log("    husky vm init --type accounting\n");
+});
+vmCommand
+    .command("init")
+    .description("Initialize agent workspace on current machine (run this ON the VM)")
+    .requiredOption("-t, --type <type>", "Business agent type slug (e.g., support, accounting, marketing, research)")
+    .option("--workspace <path>", "Workspace directory", process.env.HOME + "/workspace")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const agentTypeSlug = options.type;
+    const typeData = await getAgentTypeConfig(agentTypeSlug);
+    if (!typeData) {
+        const validTypes = listDefaultAgentTypes();
+        console.error(`Error: Unknown agent type '${agentTypeSlug}'`);
+        console.error(`Default types: ${validTypes.join(", ")}`);
+        console.error(`Or configure API to fetch custom types.`);
+        process.exit(1);
+    }
+    const { config, name: agentName } = typeData;
+    const workspace = options.workspace;
+    console.log(`\n  Initializing ${agentName}...`);
+    console.log(`  Workspace: ${workspace}\n`);
+    try {
+        if (!fs.existsSync(workspace)) {
+            fs.mkdirSync(workspace, { recursive: true });
+        }
+        for (const dir of config.directories) {
+            const fullPath = path.join(workspace, dir);
+            if (!fs.existsSync(fullPath)) {
+                fs.mkdirSync(fullPath, { recursive: true });
+                console.log(`  Created: ${dir}`);
+            }
+        }
+        const geminiDir = path.join(workspace, ".gemini", "commands");
+        if (!fs.existsSync(geminiDir)) {
+            fs.mkdirSync(geminiDir, { recursive: true });
+        }
+        const scriptsDir = path.join(workspace, "scripts");
+        if (!fs.existsSync(scriptsDir)) {
+            fs.mkdirSync(scriptsDir, { recursive: true });
+        }
+        const geminiMd = `# ${agentName} VM - Project Rules
+
+## Rolle
+Du bist ein autonomer ${agentName}. 
+
+## Tech Stack
+- Runtime: Google Cloud VM
+- AI Model: Google Vertex AI (europe-west1) - DSGVO-konform
+- CLI: Husky CLI fuer alle Business-Operationen
+
+## Workspace
+${config.directories.map((d) => `- ${d}/`).join("\n")}
+
+## Status Updates
+\`\`\`bash
+husky task message <task-id> -m "<status>"
+\`\`\`
+`;
+        fs.writeFileSync(path.join(workspace, "GEMINI.md"), geminiMd);
+        console.log(`  Created: GEMINI.md`);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, workspace, type: agentTypeSlug, name: agentName }, null, 2));
+        }
+        else {
+            console.log(`\n  ${agentName} initialized!`);
+            console.log(`\n  Next steps:`);
+            console.log(`    cd ${workspace}`);
+            console.log(`    gemini`);
+        }
+    }
+    catch (error) {
+        console.error("Error initializing agent:", error);
+        process.exit(1);
+    }
+});
+vmCommand
+    .command("startup-script")
+    .description("Generate VM startup script for agent type")
+    .requiredOption("-t, --type <type>", "Business agent type slug")
+    .option("--husky-url <url>", "Husky API URL")
+    .option("--husky-key <key>", "Husky API Key")
+    .option("--project <project>", "GCP Project ID")
+    .action(async (options) => {
+    const apiType = await fetchAgentTypeBySlug(options.type);
+    if (apiType) {
+        const script = generateStartupScript({
+            id: apiType.id,
+            departmentId: apiType.departmentId || "",
+            name: apiType.name,
+            slug: apiType.slug,
+            description: apiType.description,
+            agentConfig: apiType.agentConfig,
+            createdAt: apiType.createdAt,
+            updatedAt: apiType.updatedAt,
+        }, options.huskyUrl, options.huskyKey, options.project);
+        console.log(script);
+        return;
+    }
+    const validTypes = listDefaultAgentTypes();
+    if (!validTypes.includes(options.type)) {
+        console.error(`Error: Unknown agent type '${options.type}'`);
+        console.error(`Default types: ${validTypes.join(", ")}`);
+        process.exit(1);
+    }
+    const script = generateStartupScript(options.type, options.huskyUrl, options.huskyKey, options.project);
+    console.log(script);
+});
 // Print helpers
 function printVMSessions(sessions, stats) {
     if (sessions.length === 0) {
@@ -538,7 +757,9 @@ function printVMSessions(sessions, stats) {
     console.log(`  ${"ID".padEnd(24)} ${"NAME".padEnd(20)} ${"STATUS".padEnd(16)} ${"AGENT".padEnd(14)} CREATED`);
     console.log("  " + "-".repeat(90));
     for (const session of sessions) {
-        const truncatedName = session.name.length > 18 ? session.name.substring(0, 15) + "..." : session.name;
+        const truncatedName = session.name.length > 18
+            ? session.name.substring(0, 15) + "..."
+            : session.name;
         const status = formatStatus(session.vmStatus).padEnd(16);
         const createdAt = new Date(session.createdAt).toLocaleDateString();
         console.log(`  ${session.id.padEnd(24)} ${truncatedName.padEnd(20)} ${status} ${session.agentType.padEnd(14)} ${createdAt}`);
@@ -551,6 +772,9 @@ function printVMSessionDetail(session) {
     console.log(`  ID:           ${session.id}`);
     console.log(`  Status:       ${formatStatus(session.vmStatus)}`);
     console.log(`  Agent:        ${session.agentType}`);
+    if (session.businessAgentType) {
+        console.log(`  Type:         ${session.businessAgentType}`);
+    }
     console.log(`  VM Name:      ${session.vmName}`);
     console.log(`  Zone:         ${session.vmZone}`);
     console.log(`  Machine Type: ${session.machineType}`);