puls-dev 0.1.0

package/dist/providers/proxmox/vm.js

@@ -0,0 +1,482 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { dirname } from "node:path";
+import { createConnection } from "node:net";
+import { BaseBuilder } from "../../core/resource.js";
+import { Config } from "../../core/config.js";
+import { Output } from "../../core/output.js";
+import { getPMClient } from "./api.js";
+export class VMBuilder extends BaseBuilder {
+    out = {
+        ip: new Output(),
+        vmid: new Output(),
+    };
+    resolvedVmid = null;
+    resolvedNode = null;
+    resolvedIp = null;
+    _image;
+    _cores = 2;
+    _memory = 2048;
+    _provision;
+    _replace;
+    _node;
+    _storage;
+    _vlan;
+    _ip;
+    _sshKeys;
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverVm(name);
+    }
+    async discoverVm(name) {
+        try {
+            const pm = getPMClient();
+            const resources = await pm.get("/cluster/resources?type=vm");
+            return ((resources ?? []).find((r) => r.name === name && !r.template) ?? null);
+        }
+        catch (e) {
+            if (e.message?.includes("not configured"))
+                return null;
+            throw e;
+        }
+    }
+    image(os) {
+        this._image = os;
+        return this;
+    }
+    cores(n) {
+        this._cores = n;
+        return this;
+    }
+    memory(mb) {
+        this._memory = mb;
+        return this;
+    }
+    provision(playbookPath) {
+        this._provision = playbookPath;
+        return this;
+    }
+    replace(oldVmName) {
+        this._replace = oldVmName;
+        return this;
+    }
+    node(n) {
+        this._node = n;
+        return this;
+    }
+    storage(pool) {
+        this._storage = pool;
+        return this;
+    }
+    vlan(tag) {
+        this._vlan = tag;
+        return this;
+    }
+    ip(address) {
+        this._ip = address;
+        return this;
+    }
+    sshKey(keys) {
+        this._sshKeys = Array.isArray(keys) ? [...keys] : keys;
+        return this;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const pm = getPMClient();
+        console.log(`\n🖥️  Finalizing Proxmox VM "${this.name}"...`);
+        if (existing) {
+            this.resolvedVmid = existing.vmid;
+            this.resolvedNode = existing.node;
+            this.out.vmid.resolve(existing.vmid);
+            if (this._ip)
+                this.out.ip.resolve(this._ip.split("/")[0]);
+            console.log(`   ✅ VM "${this.name}" already exists (vmid=${existing.vmid}, node=${existing.node}, status=${existing.status})`);
+            return {
+                name: this.name,
+                vmid: this.resolvedVmid,
+                node: this.resolvedNode,
+            };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create VM "${this.name}"`);
+            if (this._image)
+                console.log(`      └─ Image: ${this._image}`);
+            console.log(`      └─ Cores: ${this._cores}  Memory: ${this._memory} MB`);
+            if (this._vlan)
+                console.log(`      └─ VLAN: ${this._vlan}`);
+            if (this._provision)
+                console.log(`      └─ Provision: ${this._provision}`);
+            if (this._replace)
+                console.log(`      └─ Replace: "${this._replace}" after creation`);
+            this.out.vmid.resolve(-1);
+            this.out.ip.resolve(this._ip?.split("/")[0] ?? "0.0.0.0");
+            return { name: this.name, vmid: "PENDING" };
+        }
+        // Find the template — match by VMID (numeric string) or name substring
+        const resources = await pm.get("/cluster/resources?type=vm");
+        const isVmid = this._image && /^\d+$/.test(this._image);
+        const template = this._image
+            ? (resources ?? []).find((r) => r.template === 1 &&
+                (isVmid
+                    ? String(r.vmid) === this._image
+                    : r.name?.includes(this._image)))
+            : null;
+        if (this._image && !template) {
+            throw new Error(`No Proxmox template found matching "${this._image}". ` +
+                (isVmid
+                    ? `Check that VMID ${this._image} exists and is marked as a template.`
+                    : `Create a template whose name contains "${this._image}".`));
+        }
+        // Resolve target node: explicit → configured nodes list → template's node → API discovery
+        let node = this._node;
+        if (!node) {
+            const configuredNodes = Config.get().providers.proxmox?.nodes;
+            node = configuredNodes?.[0] ?? template?.node;
+        }
+        if (!node) {
+            const nodes = await pm.get("/nodes");
+            node = (nodes ?? [])[0]?.node;
+        }
+        if (!node)
+            throw new Error("No Proxmox nodes available");
+        const newVmid = await pm.get("/cluster/nextid");
+        const storage = this._storage ?? "rbd_pool";
+        if (template) {
+            console.log(`   📋 Cloning template "${template.name}" (vmid=${template.vmid}) → "${this.name}" (vmid=${newVmid})`);
+            const taskId = await pm.post(`/nodes/${node}/qemu/${template.vmid}/clone`, {
+                newid: newVmid,
+                name: this.name,
+                full: 1,
+                storage,
+                format: "raw",
+            });
+            // Clone is async — wait for the Proxmox task to finish before configuring
+            await this.waitForTask(node, taskId, pm);
+        }
+        else {
+            console.log(`   🆕 Creating blank VM "${this.name}" (vmid=${newVmid})`);
+            await pm.post(`/nodes/${node}/qemu`, {
+                vmid: newVmid,
+                name: this.name,
+                cores: this._cores,
+                memory: this._memory,
+                net0: `virtio,bridge=vmbr1${this._vlan ? `,tag=${this._vlan}` : ""}`,
+                ostype: "l26",
+            });
+        }
+        this.resolvedVmid = newVmid;
+        this.resolvedNode = node;
+        this.out.vmid.resolve(newVmid);
+        // Auto-resolve static IP from internal DNS if no explicit IP set
+        if (!this._ip) {
+            const domain = Config.get().providers.proxmox?.dnsDomain;
+            if (domain) {
+                try {
+                    const { resolve4 } = await import("node:dns/promises");
+                    const [addr] = await resolve4(`${this.name}.${domain}`);
+                    this._ip = addr;
+                    console.log(`   🔍 DNS: ${this.name}.${domain} → ${addr}`);
+                }
+                catch {
+                    // Not in DNS — will fall through to DHCP
+                }
+            }
+        }
+        // Build net0 string — VirtIO on vmbr1, optional VLAN tag
+        const net0 = `virtio,bridge=vmbr1${this._vlan ? `,tag=${this._vlan}` : ""}`;
+        const configPatch = {
+            onboot: 1,
+            machine: "q35",
+            cores: this._cores,
+            memory: this._memory,
+            net0,
+            ipconfig0: this._ip
+                ? (() => {
+                    const [addr, prefix = "24"] = this._ip.split("/");
+                    const gw = addr.split(".").slice(0, 3).join(".") + ".1";
+                    return `gw=${gw},ip=${addr}/${prefix}`;
+                })()
+                : "ip=dhcp",
+            nameserver: (Config.get().providers.proxmox?.dnsServers ?? ["1.1.1.1", "8.8.8.8"]).join(" "),
+            searchdomain: Config.get().providers.proxmox?.dnsDomain ?? "",
+            ciuser: "root",
+        };
+        const pubKeys = this.resolvePublicKeys();
+        if (pubKeys.length) {
+            configPatch.sshkeys = encodeURIComponent(pubKeys.join("\n"));
+        }
+        await pm.post(`/nodes/${node}/qemu/${newVmid}/config`, configPatch);
+        await pm.post(`/nodes/${node}/qemu/${newVmid}/status/start`);
+        console.log(`🚀 Started VM "${this.name}" (vmid=${newVmid}, node=${node})`);
+        if (this._ip) {
+            const [addr] = this._ip.split("/");
+            this.resolvedIp = addr;
+            this.out.ip.resolve(addr);
+            console.log(`   🌐 IP: ${this.resolvedIp} (static)`);
+        }
+        else {
+            // Wait for qemu-agent to report an IP
+            await this.waitFor(`VM "${this.name}" to boot and get an IP`, async () => {
+                try {
+                    const ifaces = await pm.get(`/nodes/${node}/qemu/${newVmid}/agent/network-get-interfaces`);
+                    const eth = (ifaces ?? []).find((i) => i.name !== "lo");
+                    const addr = eth?.["ip-addresses"]?.find((a) => a["ip-address-type"] === "ipv4");
+                    if (addr?.["ip-address"]) {
+                        this.resolvedIp = addr["ip-address"];
+                        return true;
+                    }
+                    return false;
+                }
+                catch {
+                    return false;
+                }
+            }, { intervalMs: 10_000, timeoutMs: 300_000 });
+            if (this.resolvedIp)
+                this.out.ip.resolve(this.resolvedIp);
+            console.log(`   🌐 IP: ${this.resolvedIp}`);
+        }
+        if (this._provision) {
+            await this.waitFor(`SSH on ${this.resolvedIp} to be ready`, () => this.checkPort(this.resolvedIp, 22), { intervalMs: 10_000, timeoutMs: 300_000 });
+            await this.waitFor(`cloud-init to finish on ${this.resolvedIp}`, () => this.checkCloudInit(this.resolvedIp), { intervalMs: 15_000, timeoutMs: 300_000 });
+            await this.runProvisioner(this.resolvedIp, this._provision);
+        }
+        if (this._replace) {
+            await this.destroyVmByName(this._replace, pm);
+        }
+        return { name: this.name, vmid: this.resolvedVmid, ip: this.resolvedIp };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        console.log(`\n🗑️  Destroying Proxmox VM "${this.name}"...`);
+        if (!existing) {
+            console.log(`   ─  VM "${this.name}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Stop + delete VM "${this.name}" (vmid=${existing.vmid})`);
+            return { destroyed: this.name };
+        }
+        const pm = getPMClient();
+        await this.destroyVmByName(this.name, pm);
+        return { destroyed: this.name };
+    }
+    // Poll a Proxmox task UPID until it exits, then throw if it failed
+    async waitForTask(node, upid, pm) {
+        const encoded = encodeURIComponent(upid);
+        await this.waitFor(`clone task to complete`, async () => {
+            const status = await pm.get(`/nodes/${node}/tasks/${encoded}/status`);
+            if (status?.status !== "stopped")
+                return false;
+            if (status.exitstatus && status.exitstatus !== "OK") {
+                throw new Error(`Clone task failed: ${status.exitstatus}`);
+            }
+            return true;
+        }, { intervalMs: 5_000, timeoutMs: 300_000 });
+    }
+    async destroyVmByName(name, pm) {
+        const resources = await pm.get("/cluster/resources?type=vm");
+        const vm = (resources ?? []).find((r) => r.name === name && !r.template);
+        if (!vm) {
+            console.log(`   ℹ️  VM "${name}" not found — already gone`);
+            return;
+        }
+        if (vm.status === "running") {
+            await pm.post(`/nodes/${vm.node}/qemu/${vm.vmid}/status/stop`);
+            await this.waitFor(`VM "${name}" to stop`, async () => {
+                const s = await pm.get(`/nodes/${vm.node}/qemu/${vm.vmid}/status/current`);
+                return s?.status === "stopped";
+            }, { intervalMs: 5_000, timeoutMs: 120_000 });
+        }
+        await pm.delete(`/nodes/${vm.node}/qemu/${vm.vmid}?purge=1&destroy-unreferenced-disks=1`);
+        console.log(`   🗑️  Removed VM "${name}" (vmid=${vm.vmid})`);
+    }
+    resolvePublicKeys() {
+        const input = this._sshKeys;
+        if (!input) {
+            // Default: read ~/.ssh/id_rsa.pub if it exists
+            try {
+                return [
+                    readFileSync(`${homedir()}/.ssh/id_ed25519.pub`, "utf-8").trim(),
+                ];
+            }
+            catch {
+                return [];
+            }
+        }
+        if (Array.isArray(input))
+            return input.map((k) => k.trim()).filter(Boolean);
+        // Single string: key literal (starts with ssh-) or file path
+        if (input.startsWith("ssh-") ||
+            input.startsWith("ecdsa-") ||
+            input.startsWith("sk-")) {
+            return [input.trim()];
+        }
+        try {
+            return [
+                readFileSync(input.replace(/^~/, homedir()), "utf-8").trim(),
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+    checkCloudInit(ip) {
+        const keyPath = this.sshKeyPath();
+        return new Promise(resolve => {
+            const proc = spawn('ssh', [
+                '-i', keyPath,
+                '-o', 'StrictHostKeyChecking=no',
+                '-o', 'ConnectTimeout=10',
+                '-o', 'BatchMode=yes',
+                `root@${ip}`,
+                'cloud-init status',
+            ], { stdio: ['ignore', 'pipe', 'ignore'] });
+            let out = '';
+            proc.stdout.on('data', (d) => out += d.toString());
+            proc.on('close', () => resolve(out.includes('done') || out.includes('error')));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    checkPort(ip, port) {
+        return new Promise(resolve => {
+            const socket = createConnection({ host: ip, port, timeout: 3_000 });
+            socket.on('connect', () => { socket.destroy(); resolve(true); });
+            socket.on('timeout', () => { socket.destroy(); resolve(false); });
+            socket.on('error', () => resolve(false));
+        });
+    }
+    sshKeyPath() {
+        const keyInput = Array.isArray(this._sshKeys)
+            ? null
+            : this._sshKeys;
+        return (keyInput &&
+            !keyInput.startsWith("ssh-") &&
+            !keyInput.startsWith("ecdsa-") &&
+            !keyInput.startsWith("sk-")
+            ? keyInput.replace(/\.pub$/, "")
+            : `${homedir()}/.ssh/id_ed25519`).replace(/^~/, homedir());
+    }
+    runProvisioner(ip, script) {
+        const ext = script.split(".").pop()?.toLowerCase();
+        if (ext === "sh")
+            return this.runShellScript(ip, script);
+        if (ext === "pp")
+            return this.runPuppet(ip, script);
+        return this.runAnsible(ip, script); // .yml / .yaml
+    }
+    runShellScript(ip, script) {
+        console.log(`   🔧 Running shell script: ${script} → ${ip}`);
+        const keyPath = this.sshKeyPath();
+        const scriptDir = dirname(script); // e.g. 'config'
+        const sshArgs = [
+            "-i",
+            keyPath,
+            "-o",
+            "StrictHostKeyChecking=no",
+            "-o",
+            "ConnectTimeout=30",
+        ];
+        return new Promise((resolve, reject) => {
+            // Copy the script's directory to the same path on the remote (e.g. config/ → /config/)
+            console.log(`   📂 Copying ${scriptDir}/ → ${ip}:/${scriptDir}/`);
+            const scp = spawn("scp", [
+                "-i",
+                keyPath,
+                "-o",
+                "StrictHostKeyChecking=no",
+                "-r",
+                scriptDir,
+                `root@${ip}:/`,
+            ], { stdio: "inherit" });
+            scp.on("error", (err) => reject(new Error(`scp failed: ${err.message}`)));
+            scp.on("close", (scpCode) => {
+                if (scpCode !== 0) {
+                    reject(new Error(`scp exited with code ${scpCode}`));
+                    return;
+                }
+                const proc = spawn("ssh", [...sshArgs, `root@${ip}`, "bash -s"], {
+                    stdio: ["pipe", "inherit", "inherit"],
+                });
+                proc.stdin.write(readFileSync(script));
+                proc.stdin.end();
+                proc.on("close", (code) => {
+                    if (code === 0) {
+                        console.log(`   ✅ Provisioning complete`);
+                        resolve();
+                    }
+                    else
+                        reject(new Error(`Shell script exited with code ${code}`));
+                });
+                proc.on("error", (err) => reject(new Error(`ssh failed: ${err.message}`)));
+            });
+        });
+    }
+    runPuppet(ip, manifest) {
+        console.log(`   🔧 Applying Puppet manifest: ${manifest} → ${ip}`);
+        const keyPath = this.sshKeyPath();
+        // Copy manifest then apply it
+        return new Promise((resolve, reject) => {
+            const scp = spawn("scp", [
+                "-i",
+                keyPath,
+                "-o",
+                "StrictHostKeyChecking=no",
+                manifest,
+                `root@${ip}:/tmp/manifest.pp`,
+            ], { stdio: "inherit" });
+            scp.on("close", (code) => {
+                if (code !== 0) {
+                    reject(new Error(`scp exited with code ${code}`));
+                    return;
+                }
+                const puppet = spawn("ssh", [
+                    "-i",
+                    keyPath,
+                    "-o",
+                    "StrictHostKeyChecking=no",
+                    `root@${ip}`,
+                    "puppet apply /tmp/manifest.pp",
+                ], { stdio: "inherit" });
+                puppet.on("close", (c) => {
+                    if (c === 0) {
+                        console.log(`   ✅ Provisioning complete`);
+                        resolve();
+                    }
+                    else
+                        reject(new Error(`puppet apply exited with code ${c}`));
+                });
+                puppet.on("error", (err) => reject(new Error(`Failed to run puppet: ${err.message}`)));
+            });
+            scp.on("error", (err) => reject(new Error(`Failed to run scp: ${err.message}`)));
+        });
+    }
+    runAnsible(ip, playbook) {
+        console.log(`   🔧 Running Ansible: ${playbook} → ${ip}`);
+        const keyPath = this.sshKeyPath();
+        return new Promise((resolve, reject) => {
+            const proc = spawn("ansible-playbook", [
+                playbook,
+                "-i",
+                `${ip},`,
+                "-u",
+                "root",
+                "--private-key",
+                keyPath,
+                "--ssh-extra-args",
+                "-o StrictHostKeyChecking=no -o ConnectTimeout=30",
+            ], { stdio: "inherit" });
+            proc.on("close", (code) => {
+                if (code === 0) {
+                    console.log(`   ✅ Provisioning complete`);
+                    resolve();
+                }
+                else
+                    reject(new Error(`ansible-playbook exited with code ${code}`));
+            });
+            proc.on("error", (err) => reject(new Error(`Failed to run ansible-playbook: ${err.message}`)));
+        });
+    }
+}

package/dist/types/aws.d.ts

@@ -0,0 +1,55 @@
+export declare const DB: {
+    readonly POSTGRES_16: {
+        readonly engine: "postgres";
+        readonly version: "16";
+    };
+    readonly POSTGRES_15: {
+        readonly engine: "postgres";
+        readonly version: "15";
+    };
+    readonly MYSQL_8: {
+        readonly engine: "mysql";
+        readonly version: "8.0";
+    };
+    readonly MARIADB_11: {
+        readonly engine: "mariadb";
+        readonly version: "11.4";
+    };
+};
+export declare const DB_SIZE: {
+    readonly MICRO: "db.t3.micro";
+    readonly SMALL: "db.t3.small";
+    readonly MEDIUM: "db.t3.medium";
+    readonly LARGE: "db.r6g.large";
+};
+export declare const RUNTIME: {
+    readonly NODEJS_20: "nodejs20.x";
+    readonly NODEJS_18: "nodejs18.x";
+    readonly PYTHON_3_12: "python3.12";
+    readonly PYTHON_3_11: "python3.11";
+    readonly JAVA_21: "java21";
+    readonly DOTNET_8: "dotnet8";
+};
+export declare const SECRETS: {
+    readonly API_KEY: "myapp/api-key";
+    readonly SUPERSECRET: "test-secret-super-secret";
+};
+export declare const REGION: {
+    readonly US_EAST_1: "us-east-1";
+    readonly US_WEST_2: "us-west-2";
+    readonly EU_CENTRAL_1: "eu-central-1";
+    readonly EU_WEST_1: "eu-west-1";
+};
+export interface RegistrantContact {
+    FIRSTNAME: string;
+    LASTNAME: string;
+    EMAIL: string;
+    MOBILE: string;
+    CONTACT_TYPE: string;
+    ORGANIZATION: string;
+    ADDRESSLINE: string;
+    CITY: string;
+    ZIPCODE: string;
+    COUNTRY: string;
+}
+export declare const DOMAIN_REGISTER: RegistrantContact;

package/dist/types/aws.js

@@ -0,0 +1,48 @@
+// Define your secret IDs here — reference them everywhere instead of raw strings.
+// Example:
+// export const SECRETS = {
+//   API_KEY:     "myapp/api-key",
+//   DB_PASSWORD: "myapp/db-password",
+// } as const;
+export const DB = {
+    POSTGRES_16: { engine: "postgres", version: "16" },
+    POSTGRES_15: { engine: "postgres", version: "15" },
+    MYSQL_8: { engine: "mysql", version: "8.0" },
+    MARIADB_11: { engine: "mariadb", version: "11.4" },
+};
+export const DB_SIZE = {
+    MICRO: "db.t3.micro", // free tier eligible
+    SMALL: "db.t3.small",
+    MEDIUM: "db.t3.medium",
+    LARGE: "db.r6g.large",
+};
+export const RUNTIME = {
+    NODEJS_20: "nodejs20.x",
+    NODEJS_18: "nodejs18.x",
+    PYTHON_3_12: "python3.12",
+    PYTHON_3_11: "python3.11",
+    JAVA_21: "java21",
+    DOTNET_8: "dotnet8",
+};
+export const SECRETS = {
+    API_KEY: "myapp/api-key",
+    SUPERSECRET: "test-secret-super-secret",
+};
+export const REGION = {
+    US_EAST_1: "us-east-1",
+    US_WEST_2: "us-west-2",
+    EU_CENTRAL_1: "eu-central-1",
+    EU_WEST_1: "eu-west-1",
+};
+export const DOMAIN_REGISTER = {
+    FIRSTNAME: "first-name",
+    LASTNAME: "last-name",
+    EMAIL: "email@domain.com",
+    MOBILE: "+46.xxxxxx",
+    CONTACT_TYPE: "COMPANY",
+    ORGANIZATION: "company.com",
+    ADDRESSLINE: "address-line",
+    CITY: "city",
+    ZIPCODE: "zip-code",
+    COUNTRY: "country",
+};

package/dist/types/do.d.ts

@@ -0,0 +1,19 @@
+export declare const OS: {
+    readonly DEBIAN_11: "debian-11-x64";
+    readonly UBUNTU_22_04: "ubuntu-22-04-x64";
+};
+export declare const REGION: {
+    readonly FRA: "fra1";
+    readonly NYC: "nyc3";
+};
+export declare const SIZE: {
+    readonly SMALL: "s-1vcpu-1gb";
+    readonly MEDIUM: "s-2vcpu-4gb";
+    readonly LARGE: "s-4vcpu-8gb";
+};
+export declare const NETWORK: {
+    readonly ANY: "0.0.0.0/0";
+    readonly ANY_V6: "::/0";
+    readonly OFFICE: "80.1.2.3/32";
+    readonly VPN: "10.0.0.0/24";
+};

package/dist/types/do.js

@@ -0,0 +1,19 @@
+export const OS = {
+    DEBIAN_11: "debian-11-x64",
+    UBUNTU_22_04: "ubuntu-22-04-x64",
+};
+export const REGION = {
+    FRA: "fra1",
+    NYC: "nyc3",
+};
+export const SIZE = {
+    SMALL: "s-1vcpu-1gb",
+    MEDIUM: "s-2vcpu-4gb",
+    LARGE: "s-4vcpu-8gb",
+};
+export const NETWORK = {
+    ANY: "0.0.0.0/0",
+    ANY_V6: "::/0",
+    OFFICE: "80.1.2.3/32",
+    VPN: "10.0.0.0/24",
+};

package/dist/types/gcp.d.ts

@@ -0,0 +1,9 @@
+export declare const GCP_REGION: {
+    readonly EU_WEST1: "europe-west1";
+    readonly EU_WEST3: "europe-west3";
+    readonly EU_NORTH1: "europe-north1";
+    readonly US_CENTRAL1: "us-central1";
+    readonly US_EAST1: "us-east1";
+    readonly US_WEST1: "us-west1";
+    readonly ASIA_EAST1: "asia-east1";
+};

package/dist/types/gcp.js

@@ -0,0 +1,9 @@
+export const GCP_REGION = {
+    EU_WEST1: "europe-west1",
+    EU_WEST3: "europe-west3",
+    EU_NORTH1: "europe-north1",
+    US_CENTRAL1: "us-central1",
+    US_EAST1: "us-east1",
+    US_WEST1: "us-west1",
+    ASIA_EAST1: "asia-east1",
+};