@calltelemetry/ct-lab-mcp 0.1.2 → 0.1.4

package/dist/src/tools/provision-tools.d.ts

@@ -73,14 +73,14 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -97,15 +97,15 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -127,14 +127,14 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -151,15 +151,15 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -181,14 +181,14 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -205,15 +205,15 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
     template?: string | number | undefined;
     description?: string | undefined;
     start?: boolean | undefined;
+    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
+    memoryMb?: number | undefined;
     host?: string | undefined;
     vmid?: string | number | undefined;
-    vlan?: number | undefined;
+    ipAddress?: string | undefined;
     linearIssue?: string | undefined;
+    vlan?: number | undefined;
     slotClaimId?: string | undefined;
     cpuCores?: number | undefined;
-    ipAddress?: string | undefined;
-    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
-    memoryMb?: number | undefined;
     requester?: string | undefined;
     targetHost?: string | undefined;
     sourceVmIdOrName?: string | number | undefined;
@@ -228,4 +228,105 @@ export declare const ProvisionVmInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObje
 export type ProvisionVmInput = z.infer<typeof ProvisionVmInputSchema>;
 export type ProvisionVmRawInput = z.input<typeof ProvisionVmInputSchema>;
 export declare function handleProvisionVm(rawArgs: ProvisionVmRawInput, context: ToolContext): Promise<CallToolResult>;
+export declare const AutoProvisionVmInputShape: {
+    template: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    sourceVmIdOrName: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    name: z.ZodOptional<z.ZodString>;
+    newVmName: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    targetHost: z.ZodOptional<z.ZodString>;
+    hypervisorType: z.ZodDefault<z.ZodOptional<z.ZodEnum<["proxmox", "esxi", "any"]>>>;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    workloadType: z.ZodOptional<z.ZodEnum<["uat", "perf", "soak", "dev", "regression", "reproduction", "demo"]>>;
+    label: z.ZodOptional<z.ZodString>;
+    linearIssue: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    requester: z.ZodOptional<z.ZodString>;
+    ttlMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    durationMinutes: z.ZodOptional<z.ZodNumber>;
+    vlan: z.ZodOptional<z.ZodNumber>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    networkBridge: z.ZodOptional<z.ZodString>;
+    storage: z.ZodOptional<z.ZodString>;
+    waitForReady: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    readyTimeoutSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+};
+export declare const AutoProvisionVmInputSchema: z.ZodObject<{
+    template: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    sourceVmIdOrName: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    name: z.ZodOptional<z.ZodString>;
+    newVmName: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    targetHost: z.ZodOptional<z.ZodString>;
+    hypervisorType: z.ZodDefault<z.ZodOptional<z.ZodEnum<["proxmox", "esxi", "any"]>>>;
+    targetVersion: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    workloadType: z.ZodOptional<z.ZodEnum<["uat", "perf", "soak", "dev", "regression", "reproduction", "demo"]>>;
+    label: z.ZodOptional<z.ZodString>;
+    linearIssue: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    requester: z.ZodOptional<z.ZodString>;
+    ttlMinutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    durationMinutes: z.ZodOptional<z.ZodNumber>;
+    vlan: z.ZodOptional<z.ZodNumber>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    networkBridge: z.ZodOptional<z.ZodString>;
+    storage: z.ZodOptional<z.ZodString>;
+    waitForReady: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    readyTimeoutSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    hypervisorType: "proxmox" | "esxi" | "any";
+    ttlMinutes: number;
+    waitForReady: boolean;
+    readyTimeoutSeconds: number;
+    storage?: string | undefined;
+    name?: string | undefined;
+    tags?: string | string[] | undefined;
+    template?: string | number | undefined;
+    version?: string | undefined;
+    durationMinutes?: number | undefined;
+    host?: string | undefined;
+    ipAddress?: string | undefined;
+    targetVersion?: string | undefined;
+    workloadType?: "uat" | "perf" | "soak" | "dev" | "regression" | "reproduction" | "demo" | undefined;
+    label?: string | undefined;
+    linearIssue?: string | undefined;
+    branch?: string | undefined;
+    vlan?: number | undefined;
+    requester?: string | undefined;
+    targetHost?: string | undefined;
+    sourceVmIdOrName?: string | number | undefined;
+    newVmName?: string | undefined;
+    networkBridge?: string | undefined;
+}, {
+    storage?: string | undefined;
+    name?: string | undefined;
+    tags?: string | string[] | undefined;
+    template?: string | number | undefined;
+    version?: string | undefined;
+    hypervisorType?: "proxmox" | "esxi" | "any" | undefined;
+    durationMinutes?: number | undefined;
+    ttlMinutes?: number | undefined;
+    host?: string | undefined;
+    ipAddress?: string | undefined;
+    targetVersion?: string | undefined;
+    workloadType?: "uat" | "perf" | "soak" | "dev" | "regression" | "reproduction" | "demo" | undefined;
+    label?: string | undefined;
+    linearIssue?: string | undefined;
+    branch?: string | undefined;
+    vlan?: number | undefined;
+    requester?: string | undefined;
+    targetHost?: string | undefined;
+    sourceVmIdOrName?: string | number | undefined;
+    newVmName?: string | undefined;
+    networkBridge?: string | undefined;
+    waitForReady?: boolean | undefined;
+    readyTimeoutSeconds?: number | undefined;
+}>;
+export type AutoProvisionVmInput = z.infer<typeof AutoProvisionVmInputSchema>;
+export type AutoProvisionVmRawInput = z.input<typeof AutoProvisionVmInputSchema>;
+export declare function handleAutoProvisionVm(rawArgs: AutoProvisionVmRawInput, context: ToolContext): Promise<CallToolResult>;
 //# sourceMappingURL=provision-tools.d.ts.map

package/dist/src/tools/provision-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provision-tools.d.ts","sourceRoot":"","sources":["../../../src/tools/provision-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAA2C,MAAM,iBAAiB,CAAC;AAE1F,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAU9C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHjC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEzE,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAuKzB"}
+{"version":3,"file":"provision-tools.d.ts","sourceRoot":"","sources":["../../../src/tools/provision-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAA2C,MAAM,iBAAiB,CAAC;AAM1F,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAW9C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHjC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEzE,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAuKzB;AAMD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;CA6GrC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsC,CAAC;AAC9E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEjF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAuSzB"}

package/dist/src/tools/provision-tools.js

@@ -6,9 +6,10 @@
  */
 import { z } from "zod";
 import { ProxmoxErrorCode, createToolErrorResult } from "../types/mcp.js";
-import { formatProvisionResult } from "../utils/formatters.js";
+import { formatProvisionResult, formatAutoProvisionResult, } from "../utils/formatters.js";
 import { CapacityExceededError, GlobalCapacityExceededError, DatastoreCapacityExceededError, } from "../slot/types.js";
 import { ProtectedVmViolationError } from "../guardrails/types.js";
+import { applianceSshExecutor } from "../appliance/executor.js";
 export const ProvisionVmInputShape = {
     sourceVmIdOrName: z
         .union([z.string(), z.number()])
@@ -286,4 +287,386 @@ export async function handleProvisionVm(rawArgs, context) {
         return createToolErrorResult(ProxmoxErrorCode.UPSTREAM_API_ERROR, msg);
     }
 }
+// ============================================================================
+// Auto Provision VM (Milestone M4)
+// ============================================================================
+export const AutoProvisionVmInputShape = {
+    template: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Source VM template name or numeric VMID to clone from (e.g. '9000', 'CT-ALMALINUX9-TEMPLATE', 'CT-087-STABLE-TEMPLATE')."),
+    sourceVmIdOrName: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Alias for template."),
+    name: z
+        .string()
+        .optional()
+        .describe("Target VM name (e.g. 'ct-appliance-uat-105'). Auto-generated if omitted."),
+    newVmName: z
+        .string()
+        .optional()
+        .describe("Alias for name."),
+    host: z
+        .string()
+        .optional()
+        .describe("Target hypervisor host ('auto', 'proxmox-lab', 'proxmox-mini', 'esxi-intel-192-168-123-176'). Defaults to 'auto' for least-loaded placement."),
+    targetHost: z
+        .string()
+        .optional()
+        .describe("Alias for host."),
+    hypervisorType: z
+        .enum(["proxmox", "esxi", "any"])
+        .optional()
+        .default("any")
+        .describe("Target hypervisor platform preference: 'proxmox', 'esxi', or 'any'."),
+    targetVersion: z
+        .string()
+        .optional()
+        .describe("Call Telemetry release version to deploy/pin (e.g. '0.8.7-stable', '0.8.8')."),
+    version: z
+        .string()
+        .optional()
+        .describe("Alias for targetVersion."),
+    workloadType: z
+        .enum(["uat", "perf", "soak", "dev", "regression", "reproduction", "demo"])
+        .optional()
+        .describe("Workload category for the test slot lease (e.g. 'uat', 'perf', 'dev')."),
+    label: z
+        .string()
+        .optional()
+        .describe("Human-readable label for the slot claim and VM."),
+    linearIssue: z
+        .string()
+        .optional()
+        .describe("Linear issue key tracking this test VM (e.g. 'CTUAT-693')."),
+    branch: z
+        .string()
+        .optional()
+        .describe("Git feature/fix branch name."),
+    tags: z
+        .union([z.array(z.string()), z.string()])
+        .optional()
+        .describe("Custom tags to attach to the VM and slot lease."),
+    requester: z
+        .string()
+        .optional()
+        .describe("Requester name or agent identifier."),
+    ttlMinutes: z
+        .number()
+        .int()
+        .min(1)
+        .max(1440)
+        .optional()
+        .default(60)
+        .describe("Slot lease TTL in minutes (default: 60)."),
+    durationMinutes: z
+        .number()
+        .int()
+        .min(1)
+        .max(1440)
+        .optional()
+        .describe("Alias for ttlMinutes."),
+    vlan: z
+        .number()
+        .int()
+        .min(1)
+        .max(4094)
+        .optional()
+        .describe("VLAN tag assignment (e.g. 124, 125)."),
+    ipAddress: z
+        .string()
+        .optional()
+        .describe("Static IP address assignment for the guest VM (e.g. '192.168.124.105')."),
+    networkBridge: z
+        .string()
+        .optional()
+        .describe("Network bridge interface (e.g. 'vmbr0', 'VM Network')."),
+    storage: z
+        .string()
+        .optional()
+        .describe("Target storage pool / datastore name."),
+    waitForReady: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Whether to poll SSH:2222 / API health until the VM is ready (default: true)."),
+    readyTimeoutSeconds: z
+        .number()
+        .int()
+        .min(5)
+        .max(600)
+        .optional()
+        .default(180)
+        .describe("Readiness polling timeout in seconds (default: 180)."),
+};
+export const AutoProvisionVmInputSchema = z.object(AutoProvisionVmInputShape);
+export async function handleAutoProvisionVm(rawArgs, context) {
+    let claimedSlot;
+    let createdVmId;
+    let createdHost;
+    const startTime = Date.now();
+    try {
+        const parseResult = AutoProvisionVmInputSchema.safeParse(rawArgs);
+        if (!parseResult.success) {
+            const errMsg = parseResult.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+            return createToolErrorResult(ProxmoxErrorCode.VALIDATION_ERROR, errMsg);
+        }
+        const args = parseResult.data;
+        const rawHost = args.host || args.targetHost;
+        const targetHost = !rawHost || rawHost === "auto" ? undefined : rawHost;
+        const hypervisorType = args.hypervisorType || "any";
+        const targetVersion = args.targetVersion || args.version;
+        const workloadType = args.workloadType || "uat";
+        const linearIssue = args.linearIssue;
+        const label = args.label;
+        const branch = args.branch;
+        const durationMinutes = args.durationMinutes ?? args.ttlMinutes ?? 60;
+        const vmName = args.name ||
+            args.newVmName ||
+            `ct-appliance-${workloadType}-${Date.now().toString(36)}`;
+        const requester = args.requester || linearIssue || label || vmName;
+        const waitForReady = args.waitForReady !== false;
+        const readyTimeoutSeconds = args.readyTimeoutSeconds ?? 180;
+        let parsedTags = [];
+        if (args.tags) {
+            if (Array.isArray(args.tags)) {
+                parsedTags = args.tags;
+            }
+            else if (typeof args.tags === "string") {
+                parsedTags = args.tags.split(/[;, ]+/).map((t) => t.trim()).filter(Boolean);
+            }
+        }
+        // 1. Atomically Claim 8GB Slot Lease
+        claimedSlot = await context.slotManager.claimSlot({
+            tag: label || linearIssue || vmName,
+            requester,
+            linearIssue: linearIssue || (vmName.startsWith("CTUAT-") ? vmName : undefined),
+            label,
+            workloadType,
+            targetVersion,
+            branch,
+            customTags: parsedTags,
+            targetHost,
+            hypervisorType,
+            durationMinutes,
+            purpose: `Auto-provisioned ${workloadType} VM: ${vmName}`,
+        });
+        const hostId = claimedSlot.hostId;
+        createdHost = hostId;
+        const hypType = hostId.startsWith("esxi") ? "esxi" : "proxmox";
+        // 2. Resolve Base Template
+        let template = args.template ?? args.sourceVmIdOrName;
+        if (!template && context.hypervisorManager) {
+            try {
+                const vms = await context.hypervisorManager.listUnifiedInventory({
+                    includeTemplates: true,
+                    host: hostId,
+                });
+                const templateVm = vms.find((v) => v.isTemplate) ||
+                    vms.find((v) => v.name.toLowerCase().includes("template") ||
+                        v.name.toLowerCase().includes("tmpl") ||
+                        (v.tags && v.tags.some((t) => t.toLowerCase().includes("template"))));
+                if (templateVm) {
+                    template = templateVm.id || templateVm.name;
+                }
+            }
+            catch {
+                // fallback to default IDs
+            }
+        }
+        if (!template) {
+            if (hypType === "esxi") {
+                template = "CT-087-STABLE-TEMPLATE";
+            }
+            else if (hostId === "proxmox-mini") {
+                template = "200";
+            }
+            else {
+                template = "102";
+            }
+        }
+        // 3. Clone VM from Template
+        const cloneParams = {
+            sourceVmIdOrName: template,
+            newVmName: vmName,
+            targetHost: hostId,
+            hypervisorType: hypType,
+            fullClone: true,
+            description: `Auto-provisioned ${workloadType} VM (${linearIssue || label || "disposable"})`,
+            memoryBytes: 8192 * 1024 * 1024,
+            cpuCores: 2,
+            vlan: args.vlan,
+            ipAddress: args.ipAddress,
+            networkBridge: args.networkBridge,
+            storage: args.storage,
+            linearIssue,
+            startOnDeploy: true,
+            tags: ["disposable", workloadType, ...(targetVersion ? [targetVersion] : []), ...parsedTags],
+            requester,
+            slotClaimId: claimedSlot.claimId,
+        };
+        let provisionResult;
+        if (context.hypervisorManager) {
+            provisionResult = await context.hypervisorManager.provisionVm(cloneParams);
+        }
+        else if (context.proxmoxManager) {
+            const client = context.proxmoxManager.getClient(hostId);
+            const targetVmid = 500;
+            const sourceNum = typeof template === "number" ? template : parseInt(String(template), 10) || 9000;
+            const cloneTask = await client.cloneVm(sourceNum, targetVmid, vmName, { full: true });
+            await client.startVm(targetVmid).catch(() => { });
+            provisionResult = {
+                vmId: String(targetVmid),
+                name: vmName,
+                hostName: hostId,
+                hypervisor: "proxmox",
+                status: "running",
+                ipAddresses: args.ipAddress ? [args.ipAddress] : [],
+                vlan: args.vlan,
+                linearIssue,
+                slotClaimId: claimedSlot.claimId,
+                taskUpid: cloneTask.upid,
+                createdAt: new Date().toISOString(),
+            };
+        }
+        else {
+            throw new Error("No hypervisor manager available to provision VM.");
+        }
+        createdVmId = provisionResult.vmId;
+        // 4. Attach VM ID/Name to Slot Lease
+        await context.slotManager.attachVm(claimedSlot.claimId, provisionResult.vmId, provisionResult.name);
+        // 5. Determine Guest IP Address
+        const assignedIp = args.ipAddress ||
+            (provisionResult.ipAddresses && provisionResult.ipAddresses.length > 0
+                ? provisionResult.ipAddresses[0]
+                : `192.168.124.${100 + (Number(provisionResult.vmId) % 100 || 5)}`);
+        // 6. Polling Loop for SSH / Health Readiness
+        let healthStatus = "unverified";
+        let readyDurationMs = Date.now() - startTime;
+        if (waitForReady) {
+            const executor = context.applianceExecutor || applianceSshExecutor;
+            const pollStart = Date.now();
+            const timeoutMs = readyTimeoutSeconds * 1000;
+            let isReady = false;
+            while (Date.now() - pollStart < timeoutMs) {
+                try {
+                    const connected = await executor.testConnection(assignedIp, 2222, 2000);
+                    if (connected) {
+                        isReady = true;
+                        healthStatus = "healthy";
+                        break;
+                    }
+                }
+                catch {
+                    // continue polling
+                }
+                const elapsed = Date.now() - pollStart;
+                if (elapsed + 1000 < timeoutMs) {
+                    await new Promise((r) => setTimeout(r, Math.min(1000, timeoutMs - elapsed)));
+                }
+                else {
+                    break;
+                }
+            }
+            readyDurationMs = Date.now() - startTime;
+            if (!isReady) {
+                throw new Error(`VM readiness timed out after ${readyTimeoutSeconds}s on ${assignedIp}:2222 (healthStatus unverified).`);
+            }
+        }
+        // 7. Deploy/Pin Target Release Version if Requested
+        let deployedVersion;
+        if (targetVersion) {
+            const executor = context.applianceExecutor || applianceSshExecutor;
+            const verRes = await executor.execute({
+                targetIp: assignedIp,
+                port: 2222,
+                commandType: "set_version",
+                args: { version: targetVersion },
+                timeoutMs: 60000,
+            });
+            if (verRes.exitCode !== 0) {
+                throw new Error(`Failed to deploy requested version '${targetVersion}' on ${assignedIp}: ${verRes.stderr || verRes.stdout}`);
+            }
+            deployedVersion = targetVersion;
+        }
+        // 8. Return Verified Endpoints & Summary
+        const autoResult = {
+            success: true,
+            slotId: claimedSlot.slotId,
+            claimId: claimedSlot.claimId,
+            vmId: provisionResult.vmId,
+            vmName: provisionResult.name,
+            host: claimedSlot.hostId,
+            hypervisorType: hypType,
+            ipAddress: assignedIp,
+            sshEndpoint: {
+                host: assignedIp,
+                port: 2222,
+                user: "admin",
+            },
+            apiEndpoint: `https://${assignedIp}:443`,
+            targetVersion,
+            deployedVersion,
+            workloadType,
+            label,
+            linearIssue,
+            branch,
+            tags: parsedTags,
+            expiresAt: claimedSlot.expiresAt,
+            readyDurationMs,
+            healthStatus,
+        };
+        const formatted = formatAutoProvisionResult(autoResult);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: formatted.markdown,
+                },
+            ],
+            structuredContent: formatted.structuredContent,
+        };
+    }
+    catch (error) {
+        // Atomic Rollback: Release claimed slot if lease was acquired
+        if (claimedSlot) {
+            try {
+                await context.slotManager.releaseSlot(claimedSlot.claimId);
+            }
+            catch {
+                // ignore lease rollback error
+            }
+        }
+        // Atomic Rollback: Destroy created VM on hypervisor if created before failure
+        if (createdVmId && createdHost && context.hypervisorManager) {
+            try {
+                await context.hypervisorManager.vmAction({
+                    targetHost: createdHost,
+                    vmIdOrName: String(createdVmId),
+                    action: "destroy",
+                    force: true,
+                });
+            }
+            catch {
+                // ignore VM teardown error
+            }
+        }
+        if (error instanceof ProtectedVmViolationError) {
+            return createToolErrorResult(ProxmoxErrorCode.PROTECTED_VM_ACTION_DENIED, error.message, {
+                vmid: error.vmid,
+                vmName: error.vmName,
+                action: error.action,
+                reason: error.reason,
+            });
+        }
+        if (error instanceof CapacityExceededError ||
+            error instanceof GlobalCapacityExceededError ||
+            error instanceof DatastoreCapacityExceededError) {
+            return createToolErrorResult(ProxmoxErrorCode.CAPACITY_EXCEEDED, error.message);
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        return createToolErrorResult(ProxmoxErrorCode.UPSTREAM_API_ERROR, msg);
+    }
+}
 //# sourceMappingURL=provision-tools.js.map