puls-dev 0.1.0

package/dist/providers/firebase/storage.js

@@ -0,0 +1,117 @@
+import { readFileSync } from 'node:fs';
+import { BaseBuilder } from '../../core/resource.js';
+import { cloudFetch, getProjectId } from './api.js';
+const RULES_BASE = 'https://firebaserules.googleapis.com/v1';
+const GCS_BASE = 'https://storage.googleapis.com/storage/v1';
+export class FirebaseStorageBuilder extends BaseBuilder {
+    _rulesPath;
+    _cors = [];
+    _lifecycle;
+    _resolvedBucket;
+    constructor(bucket) {
+        // Bucket name resolved lazily in deploy() if not provided (needs projectId)
+        super(bucket ?? '__default__');
+        this._resolvedBucket = bucket;
+        this.discoveryPromise = Promise.resolve(null);
+    }
+    rules(filePath) { this._rulesPath = filePath; return this; }
+    cors(rules) { this._cors = rules; return this; }
+    lifecycle(rule) { this._lifecycle = rule; return this; }
+    bucket() {
+        return this._resolvedBucket ?? `${getProjectId()}.appspot.com`;
+    }
+    // ── Rules ─────────────────────────────────────────────────────────────────
+    releaseName() {
+        return `projects/${getProjectId()}/releases/firebase.storage/${this.bucket()}`;
+    }
+    async deployRules(dryRun) {
+        if (!this._rulesPath)
+            return;
+        const source = readFileSync(this._rulesPath, 'utf8');
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Deploy Storage rules from "${this._rulesPath}" → ${this.bucket()}`);
+            return;
+        }
+        const ruleset = await cloudFetch(RULES_BASE, `/projects/${getProjectId()}/rulesets`, {
+            method: 'POST',
+            body: JSON.stringify({ source: { files: [{ name: 'storage.rules', content: source }] } }),
+        });
+        await cloudFetch(RULES_BASE, `/${this.releaseName()}`, {
+            method: 'PUT',
+            body: JSON.stringify({ name: this.releaseName(), rulesetName: ruleset.name }),
+        });
+        console.log(`   ✅ Storage rules deployed (ruleset: ${ruleset.name.split('/').pop()})`);
+    }
+    // ── CORS ──────────────────────────────────────────────────────────────────
+    async deployCors(dryRun) {
+        if (this._cors.length === 0)
+            return;
+        const corsBody = this._cors.map(r => ({
+            origin: r.origin,
+            method: r.method,
+            responseHeader: r.responseHeader ?? [],
+            maxAgeSeconds: r.maxAge ?? 3600,
+        }));
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Set CORS on bucket "${this.bucket()}" (${this._cors.length} rule(s))`);
+            for (const r of this._cors) {
+                console.log(`      └─ origins: [${r.origin.join(', ')}], methods: [${r.method.join(', ')}]`);
+            }
+            return;
+        }
+        await cloudFetch(GCS_BASE, `/b/${this.bucket()}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ cors: corsBody }),
+        });
+        console.log(`   ✅ CORS configured on "${this.bucket()}"`);
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
+    async deployLifecycle(dryRun) {
+        if (!this._lifecycle)
+            return;
+        const rule = {
+            action: { type: 'Delete' },
+            condition: {},
+        };
+        if (this._lifecycle.deleteAfterDays !== undefined)
+            rule.condition.age = this._lifecycle.deleteAfterDays;
+        if (this._lifecycle.matchesPrefix?.length)
+            rule.condition.matchesPrefix = this._lifecycle.matchesPrefix;
+        if (dryRun) {
+            const parts = [];
+            if (this._lifecycle.deleteAfterDays)
+                parts.push(`delete after ${this._lifecycle.deleteAfterDays} days`);
+            if (this._lifecycle.matchesPrefix)
+                parts.push(`prefix: [${this._lifecycle.matchesPrefix.join(', ')}]`);
+            console.log(`   📝 [PLAN] Set lifecycle on "${this.bucket()}": ${parts.join(', ')}`);
+            return;
+        }
+        await cloudFetch(GCS_BASE, `/b/${this.bucket()}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ lifecycle: { rule: [rule] } }),
+        });
+        console.log(`   ✅ Lifecycle configured on "${this.bucket()}"`);
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
+    async deploy() {
+        // Resolve bucket name now that projectId is available
+        this._resolvedBucket = this.bucket();
+        console.log(`\n🪣  Finalizing Firebase Storage "${this._resolvedBucket}"...`);
+        const dryRun = this.isDryRunActive();
+        await this.deployRules(dryRun);
+        await this.deployCors(dryRun);
+        await this.deployLifecycle(dryRun);
+        return { bucket: this._resolvedBucket, project: getProjectId() };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        console.log(`\n🗑️  Destroying Firebase Storage config "${this.bucket()}"...`);
+        if (dryRun) {
+            console.log(`   ℹ️  Storage buckets cannot be deleted via API — remove manually in the GCP console`);
+        }
+        else {
+            console.log(`   ℹ️  Storage buckets cannot be deleted via API — remove manually in the GCP console`);
+        }
+        return { destroyed: this.bucket() };
+    }
+}

package/dist/providers/proxmox/api.d.ts

@@ -0,0 +1,12 @@
+export declare class ProxmoxApiClient {
+    private baseUrl;
+    private authToken;
+    private dispatcher?;
+    constructor(url: string, user: string, tokenName: string, tokenSecret: string, verifySsl?: boolean);
+    private request;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    delete(path: string): Promise<void>;
+}
+export declare function getPMClient(): ProxmoxApiClient;

package/dist/providers/proxmox/api.js

@@ -0,0 +1,50 @@
+import { Agent } from "undici";
+import { Config } from "../../core/config.js";
+export class ProxmoxApiClient {
+    baseUrl;
+    authToken;
+    dispatcher;
+    constructor(url, user, tokenName, tokenSecret, verifySsl = true) {
+        this.baseUrl = `${url.replace(/\/$/, "")}/api2/json`;
+        // PVE token format: USER@REALM!TOKENNAME=SECRET
+        this.authToken = `${user}!${tokenName}=${tokenSecret}`;
+        if (!verifySsl) {
+            this.dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+        }
+    }
+    async request(method, path, body) {
+        const headers = {
+            Authorization: `PVEAPIToken=${this.authToken}`,
+        };
+        if (body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        const opts = { method, headers };
+        if (body !== undefined)
+            opts.body = JSON.stringify(body);
+        if (this.dispatcher)
+            opts.dispatcher = this.dispatcher;
+        const res = await fetch(`${this.baseUrl}${path}`, opts);
+        if (!res.ok)
+            throw new Error(`Proxmox ${method} ${path}: ${res.status} ${await res.text()}`);
+        const json = (await res.json());
+        return json.data ?? null;
+    }
+    async get(path) {
+        return this.request("GET", path);
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async put(path, body) {
+        return this.request("PUT", path, body);
+    }
+    async delete(path) {
+        await this.request("DELETE", path);
+    }
+}
+export function getPMClient() {
+    const cfg = Config.get().providers.proxmox;
+    if (!cfg?.url || !cfg?.user || !cfg?.tokenName || !cfg?.tokenSecret)
+        throw new Error("Proxmox not configured. Set proxmox: { url, user, tokenName, tokenSecret } in @Deploy");
+    return new ProxmoxApiClient(cfg.url, cfg.user, cfg.tokenName, cfg.tokenSecret, cfg.verifySsl ?? true);
+}

package/dist/providers/proxmox/index.d.ts

@@ -0,0 +1,15 @@
+import { VMBuilder } from "./vm.js";
+export declare const Proxmox: {
+    init: (opts: {
+        url: string;
+        user: string;
+        tokenName: string;
+        tokenSecret: string;
+        nodes?: string[];
+        storage?: string;
+        dnsDomain?: string;
+        dnsServers?: string[];
+        verifySsl?: boolean;
+    }) => void;
+    VM: (name: string) => VMBuilder;
+};

package/dist/providers/proxmox/index.js

@@ -0,0 +1,10 @@
+import { Config } from "../../core/config.js";
+import { VMBuilder } from "./vm.js";
+export const Proxmox = {
+    init: (opts) => {
+        Config.set({
+            providers: { ...Config.get().providers, proxmox: opts },
+        });
+    },
+    VM: (name) => new VMBuilder(name),
+};

package/dist/providers/proxmox/list.d.ts

@@ -0,0 +1,2 @@
+import type { ProxmoxInventory } from '../../types/inventory.js';
+export declare function listProxmoxVMs(): Promise<ProxmoxInventory>;

package/dist/providers/proxmox/list.js

@@ -0,0 +1,15 @@
+import { getPMClient } from './api.js';
+export async function listProxmoxVMs() {
+    const resources = await getPMClient().get('/cluster/resources?type=vm');
+    const vms = (resources ?? [])
+        .filter((r) => r.template !== 1)
+        .map((r) => ({
+        name: r.name,
+        vmid: r.vmid,
+        node: r.node,
+        status: r.status,
+        maxmem: r.maxmem ?? 0,
+        maxdisk: r.maxdisk ?? 0,
+    }));
+    return { vms };
+}

package/dist/providers/proxmox/vm.d.ts

@@ -0,0 +1,61 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import type { OSImage } from "../../types/proxmox.js";
+export declare class VMBuilder extends BaseBuilder {
+    readonly out: {
+        ip: Output<string>;
+        vmid: Output<number>;
+    };
+    resolvedVmid: number | null;
+    resolvedNode: string | null;
+    resolvedIp: string | null;
+    private _image?;
+    private _cores;
+    private _memory;
+    private _provision?;
+    private _replace?;
+    private _node?;
+    private _storage?;
+    private _vlan?;
+    private _ip?;
+    private _sshKeys?;
+    constructor(name: string);
+    private discoverVm;
+    image(os: OSImage): this;
+    cores(n: number): this;
+    memory(mb: number): this;
+    provision(playbookPath: string): this;
+    replace(oldVmName: string): this;
+    node(n: string): this;
+    storage(pool: string): this;
+    vlan(tag: number): this;
+    ip(address: string): this;
+    sshKey(keys: string | readonly string[]): this;
+    deploy(): Promise<{
+        name: string;
+        vmid: number | null;
+        node: string | null;
+        ip?: undefined;
+    } | {
+        name: string;
+        vmid: string;
+        node?: undefined;
+        ip?: undefined;
+    } | {
+        name: string;
+        vmid: number;
+        ip: string | null;
+        node?: undefined;
+    }>;
+    destroy(): Promise<any>;
+    private waitForTask;
+    private destroyVmByName;
+    private resolvePublicKeys;
+    private checkCloudInit;
+    private checkPort;
+    private sshKeyPath;
+    private runProvisioner;
+    private runShellScript;
+    private runPuppet;
+    private runAnsible;
+}