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

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

@@ -0,0 +1,5 @@
+/**
+ * Instance Mapper Tests
+ */
+export {};
+//# sourceMappingURL=instance-mapper.test.d.ts.map

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

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

package/dist/test/instance-mapper.test.js

@@ -0,0 +1,118 @@
+/**
+ * Instance Mapper Tests
+ */
+import { describe, expect, test } from "bun:test";
+import { mapInstance, mapInstances } from "../src/instance-mapper.js";
+describe("Instance Mapper", () => {
+    describe("mapInstance", () => {
+        test("maps EC2 instance by kind", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/my-ec2",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "running",
+                    instanceType: "t2.micro",
+                    platformRef: { consoleUrl: "https://console.aws.amazon.com/ec2" },
+                },
+            };
+            const result = mapInstance(entry);
+            expect(result.provider).toBe("ec2");
+            expect(result.name).toBe("my-ec2");
+        });
+        test("maps GCE instance by kind", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/my-gce",
+                path: "/instances/my-gce",
+                meta: {
+                    kind: "gce:instance",
+                    status: "RUNNING",
+                    machineType: "n1-standard-1",
+                    platformRef: { consoleUrl: "https://console.cloud.google.com/compute" },
+                },
+            };
+            const result = mapInstance(entry);
+            expect(result.provider).toBe("gce");
+            expect(result.name).toBe("my-gce");
+        });
+        test("throws error for unknown kind", () => {
+            const entry = {
+                id: "unknown://id",
+                path: "/instances/unknown",
+                meta: {
+                    kind: "unknown:instance",
+                },
+            };
+            expect(() => mapInstance(entry)).toThrow("Unsupported instance kind");
+        });
+        test("throws error for missing kind", () => {
+            const entry = {
+                id: "unknown://id",
+                path: "/instances/unknown",
+                meta: {},
+            };
+            expect(() => mapInstance(entry)).toThrow("Unsupported instance kind");
+        });
+    });
+    describe("mapInstances", () => {
+        test("maps multiple instances", () => {
+            const entries = [
+                {
+                    id: "ec2://us-east-1/i-123",
+                    path: "/instances/ec2-instance",
+                    meta: {
+                        kind: "ec2:instance",
+                        instanceId: "i-123",
+                        state: "running",
+                        instanceType: "t2.micro",
+                        platformRef: { consoleUrl: "https://console.aws.amazon.com/ec2" },
+                    },
+                },
+                {
+                    id: "gce://my-project/us-central1-a/gce-instance",
+                    path: "/instances/gce-instance",
+                    meta: {
+                        kind: "gce:instance",
+                        status: "RUNNING",
+                        machineType: "n1-standard-1",
+                        platformRef: { consoleUrl: "https://console.cloud.google.com/compute" },
+                    },
+                },
+            ];
+            const result = mapInstances(entries);
+            expect(result).toHaveLength(2);
+            expect(result[0].provider).toBe("ec2");
+            expect(result[1].provider).toBe("gce");
+        });
+        test("returns empty array for empty input", () => {
+            const result = mapInstances([]);
+            expect(result).toHaveLength(0);
+        });
+        test("filters out non-instance entries", () => {
+            const entries = [
+                {
+                    id: "ec2://us-east-1/i-123",
+                    path: "/instances/ec2-instance",
+                    meta: {
+                        kind: "ec2:instance",
+                        instanceId: "i-123",
+                        state: "running",
+                        instanceType: "t2.micro",
+                        platformRef: { consoleUrl: "https://console.aws.amazon.com/ec2" },
+                    },
+                },
+                {
+                    id: "ec2://us-east-1/volumes/vol-123",
+                    path: "/volumes/my-volume",
+                    meta: {
+                        kind: "ec2:volume",
+                    },
+                },
+            ];
+            const result = mapInstances(entries, { skipUnknown: true });
+            expect(result).toHaveLength(1);
+            expect(result[0].provider).toBe("ec2");
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * EC2 Adapter Tests
+ */
+export {};
+//# sourceMappingURL=ec2.test.d.ts.map

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

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

package/dist/test/providers/ec2.test.js

@@ -0,0 +1,166 @@
+/**
+ * EC2 Adapter Tests
+ */
+import { describe, expect, test } from "bun:test";
+import { mapEC2Instance } from "../../src/providers/ec2.js";
+describe("EC2 Adapter", () => {
+    describe("mapEC2Instance", () => {
+        test("maps basic EC2 instance to ComputeInstance", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-1234567890abcdef0",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-1234567890abcdef0",
+                    state: "running",
+                    instanceType: "t2.micro",
+                    privateIp: "10.0.0.5",
+                    publicIp: "54.123.45.67",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#InstanceDetails:instanceId=i-1234567890abcdef0",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.id).toBe("i-1234567890abcdef0");
+            expect(result.name).toBe("my-instance");
+            expect(result.state).toBe("running");
+            expect(result.provider).toBe("ec2");
+            expect(result.instanceType).toBe("t2.micro");
+            expect(result.privateIp).toBe("10.0.0.5");
+            expect(result.publicIp).toBe("54.123.45.67");
+        });
+        test("maps stopped EC2 instance", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/stopped-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "stopped",
+                    instanceType: "t2.small",
+                    privateIp: "10.0.0.6",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.state).toBe("stopped");
+            expect(result.publicIp).toBeUndefined();
+        });
+        test("maps pending EC2 instance", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/pending-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "pending",
+                    instanceType: "t2.micro",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.state).toBe("pending");
+        });
+        test("maps terminated EC2 instance", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/terminated-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "terminated",
+                    instanceType: "t2.micro",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.state).toBe("terminated");
+        });
+        test("maps shutting-down to stopping", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/shutting-down-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "shutting-down",
+                    instanceType: "t2.micro",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.state).toBe("stopping");
+        });
+        test("includes platformRef with afsPath", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "running",
+                    instanceType: "t2.micro",
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.platformRef.consoleUrl).toBe("https://console.aws.amazon.com/ec2");
+            expect(result.platformRef.afsPath).toBe("/instances/my-instance");
+        });
+        test("includes aws metadata passthrough", () => {
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-1234567890abcdef0",
+                    state: "running",
+                    instanceType: "t2.micro",
+                    availabilityZone: "us-east-1a",
+                    vpcId: "vpc-12345",
+                    subnetId: "subnet-12345",
+                    tags: { Name: "my-instance", Environment: "prod" },
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.aws).toBeDefined();
+            expect(result.aws?.instanceId).toBe("i-1234567890abcdef0");
+            expect(result.aws?.availabilityZone).toBe("us-east-1a");
+            expect(result.aws?.vpcId).toBe("vpc-12345");
+        });
+        test("maps launchTime if present", () => {
+            const launchTime = "2024-01-01T00:00:00.000Z";
+            const entry = {
+                id: "ec2://us-east-1/i-123",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "ec2:instance",
+                    instanceId: "i-123",
+                    state: "running",
+                    instanceType: "t2.micro",
+                    launchTime,
+                    platformRef: {
+                        consoleUrl: "https://console.aws.amazon.com/ec2",
+                    },
+                },
+            };
+            const result = mapEC2Instance(entry);
+            expect(result.launchTime).toBeInstanceOf(Date);
+            expect(result.launchTime?.toISOString()).toBe(launchTime);
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * GCE Adapter Tests
+ */
+export {};
+//# sourceMappingURL=gce.test.d.ts.map

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

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

package/dist/test/providers/gce.test.js

@@ -0,0 +1,188 @@
+/**
+ * GCE Adapter Tests
+ */
+import { describe, expect, test } from "bun:test";
+import { mapGCEInstance } from "../../src/providers/gce.js";
+describe("GCE Adapter", () => {
+    describe("mapGCEInstance", () => {
+        test("maps basic GCE instance to ComputeInstance", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/my-instance",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "RUNNING",
+                    machineType: "n1-standard-1",
+                    privateIp: "10.0.0.5",
+                    publicIp: "35.123.45.67",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute/instancesDetail/zones/us-central1-a/instances/my-instance?project=my-project",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.id).toBe("gce://my-project/us-central1-a/my-instance");
+            expect(result.name).toBe("my-instance");
+            expect(result.state).toBe("running");
+            expect(result.provider).toBe("gce");
+            expect(result.instanceType).toBe("n1-standard-1");
+            expect(result.privateIp).toBe("10.0.0.5");
+            expect(result.publicIp).toBe("35.123.45.67");
+        });
+        test("maps STOPPED GCE instance", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/stopped-instance",
+                path: "/instances/stopped-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "STOPPED",
+                    machineType: "n1-standard-1",
+                    privateIp: "10.0.0.6",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("stopped");
+            expect(result.publicIp).toBeUndefined();
+        });
+        test("maps PROVISIONING to pending", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/provisioning-instance",
+                path: "/instances/provisioning-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "PROVISIONING",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("pending");
+        });
+        test("maps STAGING to pending", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/staging-instance",
+                path: "/instances/staging-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "STAGING",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("pending");
+        });
+        test("maps TERMINATED to terminated", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/terminated-instance",
+                path: "/instances/terminated-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "TERMINATED",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("terminated");
+        });
+        test("maps STOPPING to stopping", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/stopping-instance",
+                path: "/instances/stopping-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "STOPPING",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("stopping");
+        });
+        test("maps SUSPENDED to stopped", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/suspended-instance",
+                path: "/instances/suspended-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "SUSPENDED",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.state).toBe("stopped");
+        });
+        test("includes platformRef with afsPath", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/my-instance",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "RUNNING",
+                    machineType: "n1-standard-1",
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.platformRef.consoleUrl).toBe("https://console.cloud.google.com/compute");
+            expect(result.platformRef.afsPath).toBe("/instances/my-instance");
+        });
+        test("includes gcp metadata passthrough", () => {
+            const entry = {
+                id: "gce://my-project/us-central1-a/my-instance",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "RUNNING",
+                    machineType: "n1-standard-1",
+                    zone: "us-central1-a",
+                    labels: { env: "prod" },
+                    networkInterfaces: [{ network: "default" }],
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.gcp).toBeDefined();
+            expect(result.gcp?.zone).toBe("us-central1-a");
+            expect(result.gcp?.labels).toEqual({ env: "prod" });
+        });
+        test("maps createdAt if present", () => {
+            const createdAt = "2024-01-01T00:00:00.000Z";
+            const entry = {
+                id: "gce://my-project/us-central1-a/my-instance",
+                path: "/instances/my-instance",
+                meta: {
+                    kind: "gce:instance",
+                    status: "RUNNING",
+                    machineType: "n1-standard-1",
+                    createdAt,
+                    platformRef: {
+                        consoleUrl: "https://console.cloud.google.com/compute",
+                    },
+                },
+            };
+            const result = mapGCEInstance(entry);
+            expect(result.launchTime).toBeInstanceOf(Date);
+            expect(result.launchTime?.toISOString()).toBe(createdAt);
+        });
+    });
+});

package/dist/test/types.test.d.ts

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

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

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

package/dist/test/types.test.js

@@ -0,0 +1,96 @@
+/**
+ * Compute Abstraction Types Tests
+ */
+import { describe, expect, test } from "bun:test";
+import { COMPUTE_STATES, computeInstanceSchema } from "../src/types.js";
+describe("ComputeInstance type", () => {
+    describe("ComputeInstanceState", () => {
+        test("defines all expected states", () => {
+            expect(COMPUTE_STATES).toContain("running");
+            expect(COMPUTE_STATES).toContain("stopped");
+            expect(COMPUTE_STATES).toContain("pending");
+            expect(COMPUTE_STATES).toContain("terminated");
+            expect(COMPUTE_STATES).toContain("stopping");
+            expect(COMPUTE_STATES).toContain("unknown");
+        });
+    });
+    describe("computeInstanceSchema", () => {
+        test("validates minimal instance", () => {
+            const instance = {
+                id: "i-1234567890abcdef0",
+                name: "my-instance",
+                state: "running",
+                provider: "ec2",
+                instanceType: "t2.micro",
+                platformRef: {
+                    consoleUrl: "https://console.aws.amazon.com/ec2",
+                    afsPath: "/instances/my-instance",
+                },
+            };
+            const result = computeInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(true);
+        });
+        test("validates full instance", () => {
+            const instance = {
+                id: "i-1234567890abcdef0",
+                name: "my-instance",
+                state: "running",
+                provider: "ec2",
+                instanceType: "t2.micro",
+                vcpus: 1,
+                memoryGb: 1,
+                publicIp: "54.123.45.67",
+                privateIp: "10.0.0.5",
+                launchTime: new Date("2024-01-01T00:00:00Z"),
+                platformRef: {
+                    consoleUrl: "https://console.aws.amazon.com/ec2",
+                    afsPath: "/instances/my-instance",
+                },
+                aws: {
+                    instanceId: "i-1234567890abcdef0",
+                    availabilityZone: "us-east-1a",
+                },
+            };
+            const result = computeInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(true);
+        });
+        test("rejects instance without required fields", () => {
+            const instance = {
+                id: "i-123",
+                // missing name, state, provider, instanceType, platformRef
+            };
+            const result = computeInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(false);
+        });
+        test("rejects invalid state", () => {
+            const instance = {
+                id: "i-123",
+                name: "my-instance",
+                state: "invalid-state",
+                provider: "ec2",
+                instanceType: "t2.micro",
+                platformRef: {
+                    consoleUrl: "https://console.aws.amazon.com/ec2",
+                    afsPath: "/instances/my-instance",
+                },
+            };
+            const result = computeInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(false);
+        });
+        test("rejects invalid provider", () => {
+            const instance = {
+                id: "i-123",
+                name: "my-instance",
+                state: "running",
+                provider: "invalid-provider",
+                instanceType: "t2.micro",
+                platformRef: {
+                    consoleUrl: "https://console.aws.amazon.com/ec2",
+                    afsPath: "/instances/my-instance",
+                },
+            };
+            const result = computeInstanceSchema.safeParse(instance);
+            expect(result.success).toBe(false);
+        });
+    });
+});

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@aigne/afs-compute-abstraction",
+  "version": "1.11.0-beta.10",
+  "description": "Compute abstraction layer for AFS - unified interface for EC2, GCE instances",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./ec2": {
+      "types": "./dist/providers/ec2.d.ts",
+      "import": "./dist/providers/ec2.js"
+    },
+    "./gce": {
+      "types": "./dist/providers/gce.d.ts",
+      "import": "./dist/providers/gce.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.0.0",
+    "@aigne/afs": "1.11.0-beta.10"
+  },
+  "devDependencies": {
+    "@aigne/afs-ec2": "1.11.0-beta.10",
+    "@aigne/afs-gce": "1.11.0-beta.10",
+    "@aigne/typescript-config": "0.0.0"
+  },
+  "peerDependencies": {
+    "@aigne/afs-ec2": "1.11.0-beta.10",
+    "@aigne/afs-gce": "1.11.0-beta.10"
+  },
+  "peerDependenciesMeta": {
+    "@aigne/afs-ec2": {
+      "optional": true
+    },
+    "@aigne/afs-gce": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "keywords": [
+    "afs",
+    "compute",
+    "ec2",
+    "gce",
+    "abstraction",
+    "cloud"
+  ],
+  "author": "AIGNE",
+  "license": "See LICENSE file",
+  "scripts": {
+    "build": "tsc",
+    "check-types": "tsc --noEmit",
+    "test": "bun test"
+  }
+}