@aigne/afs-compute-abstraction 1.11.0-beta.6

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/src/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AFS Compute Abstraction
+ *
+ * Provides a unified interface for compute instances across cloud providers (EC2, GCE).
+ *
+ * @example
+ * ```typescript
+ * import { mapInstances, isInstance } from "@aigne/afs-compute-abstraction";
+ *
+ * // Get entries from AFS (EC2 or GCE providers)
+ * const entries = await afs.list("/modules/ec2/instances");
+ *
+ * // Filter to instances only
+ * const instanceEntries = entries.data.filter(isInstance);
+ *
+ * // Map to unified ComputeInstance format
+ * const instances = mapInstances(instanceEntries);
+ *
+ * // Now you can work with instances in a provider-agnostic way
+ * for (const instance of instances) {
+ *   console.log(`${instance.name}: ${instance.state} (${instance.provider})`);
+ * }
+ * ```
+ */
+export { isInstance, type MapInstancesOptions, mapInstance, mapInstances, } from "./instance-mapper.js";
+export { mapEC2Instance } from "./providers/ec2.js";
+export { mapGCEInstance } from "./providers/gce.js";
+export type { ComputeInstance, ComputeInstanceState, ComputePlatformRef, ComputeProvider, } from "./types.js";
+export { COMPUTE_PROVIDERS, COMPUTE_STATES, computeInstanceSchema, computePlatformRefSchema, EC2_STATE_MAP, GCE_STATE_MAP, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EACL,UAAU,EACV,KAAK,mBAAmB,EACxB,WAAW,EACX,YAAY,GACb,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,YAAY,EACV,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACb,aAAa,GACd,MAAM,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,30 @@
+/**
+ * AFS Compute Abstraction
+ *
+ * Provides a unified interface for compute instances across cloud providers (EC2, GCE).
+ *
+ * @example
+ * ```typescript
+ * import { mapInstances, isInstance } from "@aigne/afs-compute-abstraction";
+ *
+ * // Get entries from AFS (EC2 or GCE providers)
+ * const entries = await afs.list("/modules/ec2/instances");
+ *
+ * // Filter to instances only
+ * const instanceEntries = entries.data.filter(isInstance);
+ *
+ * // Map to unified ComputeInstance format
+ * const instances = mapInstances(instanceEntries);
+ *
+ * // Now you can work with instances in a provider-agnostic way
+ * for (const instance of instances) {
+ *   console.log(`${instance.name}: ${instance.state} (${instance.provider})`);
+ * }
+ * ```
+ */
+// Re-export mapper functions
+export { isInstance, mapInstance, mapInstances, } from "./instance-mapper.js";
+// Re-export provider-specific mappers
+export { mapEC2Instance } from "./providers/ec2.js";
+export { mapGCEInstance } from "./providers/gce.js";
+export { COMPUTE_PROVIDERS, COMPUTE_STATES, computeInstanceSchema, computePlatformRefSchema, EC2_STATE_MAP, GCE_STATE_MAP, } from "./types.js";

package/dist/src/instance-mapper.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Instance Mapper
+ *
+ * Maps AFS entries to unified ComputeInstance format based on their kind.
+ */
+import type { AFSEntry } from "@aigne/afs";
+import type { ComputeInstance } from "./types.js";
+/**
+ * Options for mapping instances
+ */
+export interface MapInstancesOptions {
+    /** Skip unknown kinds instead of throwing errors */
+    skipUnknown?: boolean;
+}
+/**
+ * Check if entry is any supported instance type
+ */
+export declare function isInstance(entry: AFSEntry): boolean;
+/**
+ * Map a single AFS entry to ComputeInstance
+ *
+ * @param entry - AFS entry from any compute provider
+ * @returns Unified ComputeInstance
+ * @throws Error if the entry kind is not supported
+ */
+export declare function mapInstance(entry: AFSEntry): ComputeInstance;
+/**
+ * Map multiple AFS entries to ComputeInstances
+ *
+ * @param entries - AFS entries from compute providers
+ * @param options - Mapping options
+ * @returns Array of unified ComputeInstances
+ */
+export declare function mapInstances(entries: AFSEntry[], options?: MapInstancesOptions): ComputeInstance[];
+//# sourceMappingURL=instance-mapper.d.ts.map

package/dist/src/instance-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-mapper.d.ts","sourceRoot":"","sources":["../../src/instance-mapper.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAgBD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,eAAe,CAU5D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,QAAQ,EAAE,EACnB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,eAAe,EAAE,CAmBnB"}

package/dist/src/instance-mapper.js

@@ -0,0 +1,66 @@
+/**
+ * Instance Mapper
+ *
+ * Maps AFS entries to unified ComputeInstance format based on their kind.
+ */
+import { mapEC2Instance } from "./providers/ec2.js";
+import { mapGCEInstance } from "./providers/gce.js";
+/**
+ * Check if entry is an EC2 instance
+ */
+function isEC2Instance(entry) {
+    return entry.metadata?.kind === "ec2:instance";
+}
+/**
+ * Check if entry is a GCE instance
+ */
+function isGCEInstance(entry) {
+    return entry.metadata?.kind === "gce:instance";
+}
+/**
+ * Check if entry is any supported instance type
+ */
+export function isInstance(entry) {
+    return isEC2Instance(entry) || isGCEInstance(entry);
+}
+/**
+ * Map a single AFS entry to ComputeInstance
+ *
+ * @param entry - AFS entry from any compute provider
+ * @returns Unified ComputeInstance
+ * @throws Error if the entry kind is not supported
+ */
+export function mapInstance(entry) {
+    if (isEC2Instance(entry)) {
+        return mapEC2Instance(entry);
+    }
+    if (isGCEInstance(entry)) {
+        return mapGCEInstance(entry);
+    }
+    throw new Error(`Unsupported instance kind: ${entry.metadata?.kind}`);
+}
+/**
+ * Map multiple AFS entries to ComputeInstances
+ *
+ * @param entries - AFS entries from compute providers
+ * @param options - Mapping options
+ * @returns Array of unified ComputeInstances
+ */
+export function mapInstances(entries, options) {
+    const result = [];
+    for (const entry of entries) {
+        if (options?.skipUnknown && !isInstance(entry)) {
+            continue;
+        }
+        try {
+            result.push(mapInstance(entry));
+        }
+        catch (error) {
+            if (!options?.skipUnknown) {
+                throw error;
+            }
+            // Skip unknown kinds when skipUnknown is true
+        }
+    }
+    return result;
+}

package/dist/src/providers/ec2.d.ts

@@ -0,0 +1,15 @@
+/**
+ * EC2 Adapter
+ *
+ * Maps EC2 instance entries to unified ComputeInstance format.
+ */
+import type { AFSEntry } from "@aigne/afs";
+import type { ComputeInstance } from "../types.js";
+/**
+ * Map EC2 instance entry to ComputeInstance
+ *
+ * @param entry - AFS entry from EC2 provider
+ * @returns Unified ComputeInstance
+ */
+export declare function mapEC2Instance(entry: AFSEntry): ComputeInstance;
+//# sourceMappingURL=ec2.d.ts.map

package/dist/src/providers/ec2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ec2.d.ts","sourceRoot":"","sources":["../../../src/providers/ec2.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,aAAa,CAAC;AAqBzE;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,eAAe,CAoD/D"}

package/dist/src/providers/ec2.js

@@ -0,0 +1,78 @@
+/**
+ * EC2 Adapter
+ *
+ * Maps EC2 instance entries to unified ComputeInstance format.
+ */
+import { EC2_STATE_MAP } from "../types.js";
+/**
+ * Extract instance name from path
+ *
+ * Path format: /instances/{name}
+ */
+function extractInstanceName(path) {
+    const segments = path.split("/").filter(Boolean);
+    return segments[segments.length - 1] || "unknown";
+}
+/**
+ * Map EC2 state to unified state
+ */
+function mapState(ec2State) {
+    if (!ec2State)
+        return "unknown";
+    return EC2_STATE_MAP[ec2State] || "unknown";
+}
+/**
+ * Map EC2 instance entry to ComputeInstance
+ *
+ * @param entry - AFS entry from EC2 provider
+ * @returns Unified ComputeInstance
+ */
+export function mapEC2Instance(entry) {
+    const metadata = entry.metadata || {};
+    // Extract AWS-specific metadata for passthrough
+    const aws = {};
+    const awsFields = [
+        "instanceId",
+        "availabilityZone",
+        "vpcId",
+        "subnetId",
+        "tags",
+        "securityGroups",
+        "iamInstanceProfile",
+        "ebsOptimized",
+        "architecture",
+        "hypervisor",
+        "rootDeviceType",
+        "rootDeviceName",
+        "blockDeviceMappings",
+        "networkInterfaces",
+        "placement",
+    ];
+    for (const field of awsFields) {
+        if (metadata[field] !== undefined) {
+            aws[field] = metadata[field];
+        }
+    }
+    // Parse launch time if present
+    let launchTime;
+    if (metadata.launchTime) {
+        launchTime = new Date(metadata.launchTime);
+    }
+    return {
+        id: metadata.instanceId || entry.id,
+        name: extractInstanceName(entry.path),
+        state: mapState(metadata.state),
+        provider: "ec2",
+        instanceType: metadata.instanceType || "unknown",
+        vcpus: metadata.vcpus,
+        memoryGb: metadata.memoryGb,
+        publicIp: metadata.publicIp,
+        privateIp: metadata.privateIp,
+        launchTime,
+        platformRef: {
+            consoleUrl: metadata.platformRef?.consoleUrl || "",
+            afsPath: entry.path,
+        },
+        aws: Object.keys(aws).length > 0 ? aws : undefined,
+    };
+}

package/dist/src/providers/gce.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GCE Adapter
+ *
+ * Maps GCE instance entries to unified ComputeInstance format.
+ */
+import type { AFSEntry } from "@aigne/afs";
+import type { ComputeInstance } from "../types.js";
+/**
+ * Map GCE instance entry to ComputeInstance
+ *
+ * @param entry - AFS entry from GCE provider
+ * @returns Unified ComputeInstance
+ */
+export declare function mapGCEInstance(entry: AFSEntry): ComputeInstance;
+//# sourceMappingURL=gce.d.ts.map

package/dist/src/providers/gce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gce.d.ts","sourceRoot":"","sources":["../../../src/providers/gce.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,aAAa,CAAC;AAqBzE;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,eAAe,CAgD/D"}

package/dist/src/providers/gce.js

@@ -0,0 +1,74 @@
+/**
+ * GCE Adapter
+ *
+ * Maps GCE instance entries to unified ComputeInstance format.
+ */
+import { GCE_STATE_MAP } from "../types.js";
+/**
+ * Extract instance name from path
+ *
+ * Path format: /instances/{name}
+ */
+function extractInstanceName(path) {
+    const segments = path.split("/").filter(Boolean);
+    return segments[segments.length - 1] || "unknown";
+}
+/**
+ * Map GCE status to unified state
+ */
+function mapState(gceStatus) {
+    if (!gceStatus)
+        return "unknown";
+    return GCE_STATE_MAP[gceStatus] || "unknown";
+}
+/**
+ * Map GCE instance entry to ComputeInstance
+ *
+ * @param entry - AFS entry from GCE provider
+ * @returns Unified ComputeInstance
+ */
+export function mapGCEInstance(entry) {
+    const metadata = entry.metadata || {};
+    // Extract GCP-specific metadata for passthrough
+    const gcp = {};
+    const gcpFields = [
+        "zone",
+        "labels",
+        "networkInterfaces",
+        "disks",
+        "serviceAccounts",
+        "scheduling",
+        "metadata",
+        "tags",
+        "canIpForward",
+        "startRestricted",
+        "deletionProtection",
+    ];
+    for (const field of gcpFields) {
+        if (metadata[field] !== undefined) {
+            gcp[field] = metadata[field];
+        }
+    }
+    // Parse creation time if present
+    let launchTime;
+    if (metadata.createdAt) {
+        launchTime = new Date(metadata.createdAt);
+    }
+    return {
+        id: entry.id,
+        name: extractInstanceName(entry.path),
+        state: mapState(metadata.status),
+        provider: "gce",
+        instanceType: metadata.machineType || "unknown",
+        vcpus: metadata.vcpus,
+        memoryGb: metadata.memoryGb,
+        publicIp: metadata.publicIp,
+        privateIp: metadata.privateIp,
+        launchTime,
+        platformRef: {
+            consoleUrl: metadata.platformRef?.consoleUrl || "",
+            afsPath: entry.path,
+        },
+        gcp: Object.keys(gcp).length > 0 ? gcp : undefined,
+    };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Compute Abstraction Types
+ *
+ * Unified types for compute instances across cloud providers.
+ */
+import { z } from "zod";
+/**
+ * Supported cloud providers
+ */
+export declare const COMPUTE_PROVIDERS: readonly ["ec2", "gce"];
+export type ComputeProvider = (typeof COMPUTE_PROVIDERS)[number];
+/**
+ * Unified instance states
+ */
+export declare const COMPUTE_STATES: readonly ["running", "stopped", "pending", "terminated", "stopping", "unknown"];
+export type ComputeInstanceState = (typeof COMPUTE_STATES)[number];
+/**
+ * Platform reference for the original resource
+ */
+export interface ComputePlatformRef {
+    /** URL to the cloud console for this resource */
+    consoleUrl: string;
+    /** Original AFS path in the provider */
+    afsPath: string;
+}
+/**
+ * Unified compute instance type
+ *
+ * Represents a compute instance from any supported cloud provider
+ * with normalized fields for easy comparison and manipulation.
+ */
+export interface ComputeInstance {
+    /** Unique identifier (provider-specific) */
+    id: string;
+    /** Instance name */
+    name: string;
+    /** Normalized instance state */
+    state: ComputeInstanceState;
+    /** Source provider */
+    provider: ComputeProvider;
+    /** Instance type (original name, e.g., "t2.micro", "n1-standard-1") */
+    instanceType: string;
+    /** Number of vCPUs (if available) */
+    vcpus?: number;
+    /** Memory in GB (if available) */
+    memoryGb?: number;
+    /** Public IP address (if assigned) */
+    publicIp?: string;
+    /** Private IP address */
+    privateIp?: string;
+    /** Instance launch time */
+    launchTime?: Date;
+    /** Platform reference for console URL and original path */
+    platformRef: ComputePlatformRef;
+    /** AWS-specific metadata (passthrough) */
+    aws?: Record<string, unknown>;
+    /** GCP-specific metadata (passthrough) */
+    gcp?: Record<string, unknown>;
+}
+/**
+ * Zod schema for platform reference
+ */
+export declare const computePlatformRefSchema: z.ZodObject<{
+    consoleUrl: z.ZodString;
+    afsPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    consoleUrl: string;
+    afsPath: string;
+}, {
+    consoleUrl: string;
+    afsPath: string;
+}>;
+/**
+ * Zod schema for compute instance validation
+ */
+export declare const computeInstanceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    state: z.ZodEnum<["running", "stopped", "pending", "terminated", "stopping", "unknown"]>;
+    provider: z.ZodEnum<["ec2", "gce"]>;
+    instanceType: z.ZodString;
+    vcpus: z.ZodOptional<z.ZodNumber>;
+    memoryGb: z.ZodOptional<z.ZodNumber>;
+    publicIp: z.ZodOptional<z.ZodString>;
+    privateIp: z.ZodOptional<z.ZodString>;
+    launchTime: z.ZodOptional<z.ZodDate>;
+    platformRef: z.ZodObject<{
+        consoleUrl: z.ZodString;
+        afsPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        consoleUrl: string;
+        afsPath: string;
+    }, {
+        consoleUrl: string;
+        afsPath: string;
+    }>;
+    aws: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    gcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    state: "running" | "stopped" | "pending" | "terminated" | "stopping" | "unknown";
+    provider: "ec2" | "gce";
+    instanceType: string;
+    platformRef: {
+        consoleUrl: string;
+        afsPath: string;
+    };
+    vcpus?: number | undefined;
+    memoryGb?: number | undefined;
+    publicIp?: string | undefined;
+    privateIp?: string | undefined;
+    launchTime?: Date | undefined;
+    aws?: Record<string, unknown> | undefined;
+    gcp?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    name: string;
+    state: "running" | "stopped" | "pending" | "terminated" | "stopping" | "unknown";
+    provider: "ec2" | "gce";
+    instanceType: string;
+    platformRef: {
+        consoleUrl: string;
+        afsPath: string;
+    };
+    vcpus?: number | undefined;
+    memoryGb?: number | undefined;
+    publicIp?: string | undefined;
+    privateIp?: string | undefined;
+    launchTime?: Date | undefined;
+    aws?: Record<string, unknown> | undefined;
+    gcp?: Record<string, unknown> | undefined;
+}>;
+/**
+ * State mapping from EC2 states to unified states
+ */
+export declare const EC2_STATE_MAP: Record<string, ComputeInstanceState>;
+/**
+ * State mapping from GCE states to unified states
+ */
+export declare const GCE_STATE_MAP: Record<string, ComputeInstanceState>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,iBAAiB,yBAA0B,CAAC;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,cAAc,iFAOjB,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IAEX,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IAEb,gCAAgC;IAChC,KAAK,EAAE,oBAAoB,CAAC;IAE5B,sBAAsB;IACtB,QAAQ,EAAE,eAAe,CAAC;IAE1B,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IAErB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,2BAA2B;IAC3B,UAAU,CAAC,EAAE,IAAI,CAAC;IAElB,2DAA2D;IAC3D,WAAW,EAAE,kBAAkB,CAAC;IAEhC,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAO9D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAS9D,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,70 @@
+/**
+ * Compute Abstraction Types
+ *
+ * Unified types for compute instances across cloud providers.
+ */
+import { z } from "zod";
+/**
+ * Supported cloud providers
+ */
+export const COMPUTE_PROVIDERS = ["ec2", "gce"];
+/**
+ * Unified instance states
+ */
+export const COMPUTE_STATES = [
+    "running",
+    "stopped",
+    "pending",
+    "terminated",
+    "stopping",
+    "unknown",
+];
+/**
+ * Zod schema for platform reference
+ */
+export const computePlatformRefSchema = z.object({
+    consoleUrl: z.string(),
+    afsPath: z.string(),
+});
+/**
+ * Zod schema for compute instance validation
+ */
+export const computeInstanceSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    state: z.enum(COMPUTE_STATES),
+    provider: z.enum(COMPUTE_PROVIDERS),
+    instanceType: z.string(),
+    vcpus: z.number().int().positive().optional(),
+    memoryGb: z.number().positive().optional(),
+    publicIp: z.string().optional(),
+    privateIp: z.string().optional(),
+    launchTime: z.date().optional(),
+    platformRef: computePlatformRefSchema,
+    aws: z.record(z.unknown()).optional(),
+    gcp: z.record(z.unknown()).optional(),
+});
+/**
+ * State mapping from EC2 states to unified states
+ */
+export const EC2_STATE_MAP = {
+    running: "running",
+    stopped: "stopped",
+    pending: "pending",
+    terminated: "terminated",
+    stopping: "stopping",
+    "shutting-down": "stopping",
+};
+/**
+ * State mapping from GCE states to unified states
+ */
+export const GCE_STATE_MAP = {
+    RUNNING: "running",
+    STOPPED: "stopped",
+    TERMINATED: "terminated",
+    PROVISIONING: "pending",
+    STAGING: "pending",
+    STOPPING: "stopping",
+    SUSPENDING: "stopping",
+    SUSPENDED: "stopped",
+};

package/dist/test/index.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compute Abstraction Index Tests
+ */
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/test/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../test/index.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}