puls-dev 0.1.8 → 0.2.0

package/dist/providers/firebase/functions.js

@@ -1,5 +1,5 @@
-import { execSync } from "node:child_process";
-import { mkdtempSync, readFileSync } from "node:fs";
+import cp from "node:child_process";
+import fs from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { BaseBuilder } from "../../core/resource.js";
@@ -26,8 +26,22 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
     _env = {};
     constructor(functionName) {
         super(functionName);
-        // Discovery runs lazily in deploy() because we need _region, which may not be set at construction time
-        this.discoveryPromise = Promise.resolve(null);
+        this.discoveryPromise = Promise.resolve().then(() => this.discoverFunction());
+    }
+    async discoverFunction() {
+        try {
+            return await this.getExisting();
+        }
+        catch (e) {
+            if (e.message?.includes("403") ||
+                e.message?.includes("404") ||
+                e.message?.includes("Firebase not configured") ||
+                e.message?.includes("private_key") ||
+                e.code === "MISSING_CREDENTIALS") {
+                return null;
+            }
+            throw e;
+        }
     }
     source(path) {
         this._sourcePath = path;
@@ -81,12 +95,12 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
     zipSource() {
         if (!this._sourcePath)
             throw new Error(`[Firebase.Functions:${this.name}] .source() is required`);
-        const tmp = mkdtempSync(join(tmpdir(), "puls-fn-"));
+        const tmp = fs.mkdtempSync(join(tmpdir(), "puls-fn-"));
         const zipPath = join(tmp, "function.zip");
-        execSync(`cd "${this._sourcePath}" && zip -r "${zipPath}" .`, {
+        cp.execSync(`cd "${this._sourcePath}" && zip -r "${zipPath}" .`, {
             stdio: "pipe",
         });
-        return readFileSync(zipPath);
+        return fs.readFileSync(zipPath);
     }
     async uploadSource() {
         const { uploadUrl, storageSource } = await cloudFetch(CF_BASE, `/projects/${getProjectId()}/locations/${this._region}/functions:generateUploadUrl`, { method: "POST", body: "{}" });
@@ -121,7 +135,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
         if (!this._sourcePath)
             throw new Error(`[Firebase.Functions:${this.name}] .source() is required`);
         if (dryRun) {
-            const existing = await this.getExisting();
+            const existing = await this.discoveryPromise;
             if (existing) {
                 console.log(`   ✅ Function "${this.name}" exists (${existing.state ?? "ACTIVE"})`);
                 console.log(`   📝 [PLAN] Update → ${this._runtime}, ${this._memory}, ${this._timeout}s timeout`);
@@ -155,7 +169,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
                 ingressSettings: "ALLOW_ALL",
             },
         };
-        const existing = await this.getExisting();
+        const existing = await this.discoveryPromise;
         let op;
         if (!existing) {
             op = await cloudFetch(CF_BASE, `/projects/${project}/locations/${this._region}/functions?functionId=${this.name}`, { method: "POST", body: JSON.stringify(body) });
@@ -179,7 +193,7 @@ export class FirebaseFunctionsBuilder extends BaseBuilder {
     async destroy() {
         const dryRun = this.isDryRunActive();
         console.log(`\n🗑️  Destroying Firebase Function "${this.name}"...`);
-        const existing = await this.getExisting();
+        const existing = await this.discoveryPromise;
         if (!existing) {
             console.log(`   ✅ Function "${this.name}" does not exist - nothing to do`);
             return { destroyed: this.name };

package/dist/providers/firebase/functions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/firebase/functions.test.js

@@ -0,0 +1,297 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import cp from 'node:child_process';
+import { GoogleAuth } from 'google-auth-library';
+import { FirebaseFunctionsBuilder } from './functions.js';
+import { Config } from '../../core/config.js';
+describe('FirebaseFunctionsBuilder Unit Tests', () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                firebase: {
+                    projectId: 'my-project',
+                    serviceAccountPath: '/fake/sa.json'
+                }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? 'GET';
+            let body;
+            if (init?.body) {
+                if (typeof init.body === 'string') {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = '[Binary/Buffer Body]';
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter(key => {
+                const [mMethod, mPath] = key.split(' ');
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(' ')[1].length - a.split(' ')[1].length)[0];
+            if (matchKey) {
+                let resp = mockResponses[matchKey];
+                if (typeof resp === 'function') {
+                    resp = resp();
+                }
+                const status = resp.status;
+                const body = resp.body;
+                return {
+                    ok: status >= 200 && status < 300,
+                    status,
+                    json: async () => body,
+                    text: async () => JSON.stringify(body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ error: { message: `Endpoint not mocked: ${method} ${url}` } }),
+                text: async () => `Endpoint not mocked: ${method} ${url}`,
+            };
+        };
+        // 1. Mock GoogleAuth prototype to completely bypass filesystem SA key loading and OAuth
+        mock.method(GoogleAuth.prototype, 'getClient', async () => {
+            return {
+                getAccessToken: async () => ({ token: 'fake-access-token' })
+            };
+        });
+        // 2. Mock filesystem / subprocesses to prevent real zip generation
+        mock.method(fs, 'mkdtempSync', () => '/fake/tmp/puls-fn-123');
+        mock.method(fs, 'readFileSync', () => Buffer.from('mock-zip-bytes'));
+        mock.method(cp, 'execSync', () => Buffer.from('mock-zip-stdout'));
+        // 3. Fast-forward setTimeout to bypass poll timers
+        mock.method(global, 'setTimeout', (fn) => fn());
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test('gracefully handles discovery when function does not exist', async () => {
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 404,
+            body: { error: { message: 'Function not found' } }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        const apiCall = fetchCalls.find(c => c.url.includes('/functions/my-fn'));
+        assert.ok(apiCall);
+        assert.strictEqual(apiCall.method, 'GET');
+    });
+    test('discovers function successfully when it exists', async () => {
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 200,
+            body: {
+                name: 'projects/my-project/locations/us-central1/functions/my-fn',
+                state: 'ACTIVE',
+                serviceConfig: { uri: 'https://my-fn-live-url' }
+            }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.name, 'projects/my-project/locations/us-central1/functions/my-fn');
+        assert.strictEqual(discoveryResult.state, 'ACTIVE');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                firebase: { projectId: 'my-project', serviceAccountPath: '/fake/sa.json' }
+            }
+        });
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 404,
+            body: { error: { message: 'Function not found' } }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        builder
+            .source('./src')
+            .entryPoint('main')
+            .runtime('nodejs22')
+            .region('us-central1')
+            .memory('512M')
+            .timeout(120)
+            .maxInstances(50)
+            .minInstances(2)
+            .env({ MY_VAR: 'value' });
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fn');
+        assert.strictEqual(result.project, 'my-project');
+        assert.strictEqual(result.region, 'us-central1');
+        // No write calls (POST, PUT, PATCH, DELETE) should be made
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys new function when missing, performing upload and polling', async () => {
+        let getCallCount = 0;
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = (() => {
+            getCallCount++;
+            if (getCallCount === 1) {
+                return {
+                    status: 404,
+                    body: { error: { message: 'Function not found' } }
+                };
+            }
+            return {
+                status: 200,
+                body: {
+                    name: 'projects/my-project/locations/us-central1/functions/my-fn',
+                    serviceConfig: { uri: 'https://live-uri.net' }
+                }
+            };
+        });
+        mockResponses['POST /functions:generateUploadUrl'] = {
+            status: 200,
+            body: {
+                uploadUrl: 'https://upload-gcs.googleapis.com/upload-my-zip',
+                storageSource: { bucket: 'my-bucket', object: 'my-zip' }
+            }
+        };
+        mockResponses['PUT /upload-my-zip'] = {
+            status: 200,
+            body: {}
+        };
+        mockResponses['POST /functions?functionId=my-fn'] = {
+            status: 200,
+            body: { name: 'projects/my-project/locations/us-central1/operations/op-create-123' }
+        };
+        mockResponses['GET /operations/op-create-123'] = {
+            status: 200,
+            body: { done: true }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        builder
+            .source('./src')
+            .entryPoint('main')
+            .env({ API_KEY: 'secret' });
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fn');
+        assert.strictEqual(result.url, 'https://live-uri.net');
+        assert.strictEqual(result.project, 'my-project');
+        assert.strictEqual(result.region, 'us-central1');
+        // Assert generateUploadUrl was called
+        const uploadUrlCall = fetchCalls.find(c => c.method === 'POST' && c.url.endsWith('/functions:generateUploadUrl'));
+        assert.ok(uploadUrlCall);
+        // Assert zip upload call was sent via PUT to the generated upload URL
+        const uploadCall = fetchCalls.find(c => c.method === 'PUT' && c.url.includes('/upload-my-zip'));
+        assert.ok(uploadCall);
+        assert.strictEqual(uploadCall.body, '[Binary/Buffer Body]');
+        // Assert POST create function was called with configuration
+        const createCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/functions?functionId=my-fn'));
+        assert.ok(createCall);
+        assert.strictEqual(createCall.body.buildConfig.entryPoint, 'main');
+        assert.deepStrictEqual(createCall.body.buildConfig.environmentVariables, { API_KEY: 'secret' });
+        assert.strictEqual(createCall.body.serviceConfig.availableMemory, '256M');
+        // Assert polling call was sent
+        const pollCall = fetchCalls.find(c => c.method === 'GET' && c.url.endsWith('/operations/op-create-123'));
+        assert.ok(pollCall);
+    });
+    test('updates existing function code and configurations correctly', async () => {
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 200,
+            body: {
+                name: 'projects/my-project/locations/us-central1/functions/my-fn',
+                state: 'ACTIVE',
+                serviceConfig: { uri: 'https://my-fn-live-url' }
+            }
+        };
+        mockResponses['POST /functions:generateUploadUrl'] = {
+            status: 200,
+            body: {
+                uploadUrl: 'https://upload-gcs.googleapis.com/upload-my-zip',
+                storageSource: { bucket: 'my-bucket', object: 'my-zip' }
+            }
+        };
+        mockResponses['PUT /upload-my-zip'] = {
+            status: 200,
+            body: {}
+        };
+        mockResponses['PATCH /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 200,
+            body: { name: 'projects/my-project/locations/us-central1/operations/op-update-456' }
+        };
+        mockResponses['GET /operations/op-update-456'] = {
+            status: 200,
+            body: { done: true }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        builder
+            .source('./src')
+            .entryPoint('updatedMain')
+            .runtime('nodejs22')
+            .memory('512M');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-fn');
+        // Assert PATCH call was made
+        const patchCall = fetchCalls.find(c => c.method === 'PATCH' && c.url.includes('/functions/my-fn'));
+        assert.ok(patchCall);
+        assert.ok(patchCall.url.includes('updateMask='));
+        assert.strictEqual(patchCall.body.buildConfig.entryPoint, 'updatedMain');
+        assert.strictEqual(patchCall.body.buildConfig.runtime, 'nodejs22');
+        assert.strictEqual(patchCall.body.serviceConfig.availableMemory, '512M');
+        // Assert polling occurred
+        const pollCall = fetchCalls.find(c => c.method === 'GET' && c.url.endsWith('/operations/op-update-456'));
+        assert.ok(pollCall);
+    });
+    test('destroys existing function successfully', async () => {
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 200,
+            body: {
+                name: 'projects/my-project/locations/us-central1/functions/my-fn',
+                state: 'ACTIVE'
+            }
+        };
+        mockResponses['DELETE /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 200,
+            body: { name: 'projects/my-project/locations/us-central1/operations/op-delete-789' }
+        };
+        mockResponses['GET /operations/op-delete-789'] = {
+            status: 200,
+            body: { done: true }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-fn' });
+        // Assert DELETE was called
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE' && c.url.includes('/functions/my-fn'));
+        assert.ok(deleteCall);
+        // Assert polling occurred
+        const pollCall = fetchCalls.find(c => c.method === 'GET' && c.url.endsWith('/operations/op-delete-789'));
+        assert.ok(pollCall);
+    });
+    test('destroys does nothing when function does not exist', async () => {
+        mockResponses['GET /projects/my-project/locations/us-central1/functions/my-fn'] = {
+            status: 404,
+            body: { error: { message: 'Function not found' } }
+        };
+        const builder = new FirebaseFunctionsBuilder('my-fn');
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: 'my-fn' });
+        // Verify no DELETE call was placed
+        const deleteCall = fetchCalls.find(c => c.method === 'DELETE');
+        assert.strictEqual(deleteCall, undefined);
+    });
+});

package/dist/providers/firebase/hosting.d.ts

@@ -1,8 +1,10 @@
 import { BaseBuilder } from "../../core/resource.js";
 export declare class FirebaseHostingBuilder extends BaseBuilder {
     private _sourcePath?;
+    private _domain?;
     constructor(siteId: string);
     source(path: string): this;
+    domain(name: string): this;
     private discoverSite;
     deploy(): Promise<{
         siteId: string;

package/dist/providers/firebase/hosting.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readdirSync, statSync, readFileSync } from "node:fs";
+import fs from "node:fs";
 import { join, relative } from "node:path";
 import { gzipSync } from "node:zlib";
 import { BaseBuilder } from "../../core/resource.js";
@@ -21,9 +21,9 @@ const CONTENT_TYPES = {
 };
 function walkDir(dir) {
     const results = [];
-    for (const entry of readdirSync(dir)) {
+    for (const entry of fs.readdirSync(dir)) {
         const full = join(dir, entry);
-        if (statSync(full).isDirectory()) {
+        if (fs.statSync(full).isDirectory()) {
             results.push(...walkDir(full));
         }
         else {
@@ -33,20 +33,25 @@ function walkDir(dir) {
     return results;
 }
 function sha256(filePath) {
-    const content = readFileSync(filePath);
+    const content = fs.readFileSync(filePath);
     return createHash("sha256").update(content).digest("hex");
 }
 export class FirebaseHostingBuilder extends BaseBuilder {
     _sourcePath;
+    _domain;
     constructor(siteId) {
         super(siteId);
-        // Discovery: check if the site has any releases (confirms it exists and is active)
+        // Discovery: check if the site exists
         this.discoveryPromise = this.discoverSite(siteId);
     }
     source(path) {
         this._sourcePath = path;
         return this;
     }
+    domain(name) {
+        this._domain = name;
+        return this;
+    }
     async discoverSite(siteId) {
         try {
             const projectId = getProjectId();
@@ -75,7 +80,8 @@ export class FirebaseHostingBuilder extends BaseBuilder {
             throw new Error(`[Firebase.Hosting:${siteId}] No files found in "${this._sourcePath}"`);
         const existing = await this.discoveryPromise;
         if (dryRun) {
-            console.log(`   📝 [PLAN] Deploy ${files.length} file(s) to https://${siteId}.web.app`);
+            const displayUrl = this._domain ? `https://${this._domain}` : `https://${siteId}.web.app`;
+            console.log(`   📝 [PLAN] Deploy ${files.length} file(s) to ${displayUrl}`);
             if (!existing)
                 console.log(`      └─ Will create secondary site "${siteId}"`);
             for (const f of files.slice(0, 5)) {
@@ -83,7 +89,7 @@ export class FirebaseHostingBuilder extends BaseBuilder {
             }
             if (files.length > 5)
                 console.log(`      └─ ... and ${files.length - 5} more`);
-            return { siteId, url: `https://${siteId}.web.app` };
+            return { siteId, url: displayUrl };
         }
         // 0. Ensure site exists (for secondary sites)
         if (!existing) {
@@ -119,7 +125,7 @@ export class FirebaseHostingBuilder extends BaseBuilder {
         const hashToUrl = {};
         for (const absPath of files) {
             const urlPath = "/" + relative(this._sourcePath, absPath).replace(/\\/g, "/");
-            const content = readFileSync(absPath);
+            const content = fs.readFileSync(absPath);
             const compressed = gzipSync(content);
             const hash = createHash("sha256").update(compressed).digest("hex");
             fileMap[urlPath] = hash;
@@ -164,7 +170,7 @@ export class FirebaseHostingBuilder extends BaseBuilder {
             method: "POST",
             body: JSON.stringify({}),
         });
-        const url = `https://${siteId}.web.app`;
+        const url = this._domain ? `https://${this._domain}` : `https://${siteId}.web.app`;
         console.log(`🚀 Deployed ${files.length} file(s) → ${url}`);
         return { siteId, url };
     }

package/dist/providers/firebase/hosting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/firebase/hosting.test.js

@@ -0,0 +1,181 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { GoogleAuth } from 'google-auth-library';
+import { FirebaseHostingBuilder } from './hosting.js';
+import { Config } from '../../core/config.js';
+describe('FirebaseHostingBuilder Unit Tests', () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        // Configure Firebase provider with fake credentials
+        Config.set({
+            dryRun: false,
+            providers: {
+                firebase: {
+                    projectId: 'my-project',
+                    serviceAccountPath: '/fake/sa.json'
+                }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? 'GET';
+            let body;
+            if (init?.body) {
+                if (typeof init.body === 'string') {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = '[Binary/Buffer Body]';
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses)
+                .filter(key => {
+                const [mMethod, mPath] = key.split(' ');
+                return method === mMethod && url.includes(mPath);
+            })
+                .sort((a, b) => b.split(' ')[1].length - a.split(' ')[1].length)[0];
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ message: `Endpoint not mocked: ${method} ${url}` }),
+                text: async () => `Endpoint not mocked: ${method} ${url}`,
+            };
+        };
+        // 1. Mock GoogleAuth prototype to completely bypass filesystem SA key loading and OAuth
+        mock.method(GoogleAuth.prototype, 'getClient', async () => {
+            return {
+                getAccessToken: async () => ({ token: 'fake-access-token' })
+            };
+        });
+        // 2. Mock filesystem calls specifically for the test source folder ./dist
+        mock.method(fs, 'readdirSync', () => {
+            return ['index.html'];
+        });
+        mock.method(fs, 'statSync', () => {
+            return {
+                isDirectory: () => false
+            };
+        });
+        mock.method(fs, 'readFileSync', () => {
+            return Buffer.from('hello from index.html');
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        mock.restoreAll();
+    });
+    test('gracefully handles discovery when site does not exist', async () => {
+        mockResponses['GET /projects/my-project/sites/my-site'] = {
+            status: 404,
+            body: { error: { message: 'Site not found' } }
+        };
+        const builder = new FirebaseHostingBuilder('my-site');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.strictEqual(discoveryResult, null);
+        const apiCall = fetchCalls.find(c => c.url.includes('/sites/my-site'));
+        assert.ok(apiCall);
+        assert.strictEqual(apiCall.method, 'GET');
+    });
+    test('discovers site successfully when it exists', async () => {
+        mockResponses['GET /projects/my-project/sites/my-site'] = {
+            status: 200,
+            body: { name: 'projects/my-project/sites/my-site', type: 'USER_SITE' }
+        };
+        const builder = new FirebaseHostingBuilder('my-site');
+        const discoveryResult = await builder.discoveryPromise;
+        assert.ok(discoveryResult);
+        assert.strictEqual(discoveryResult.name, 'projects/my-project/sites/my-site');
+    });
+    test('performs clean dry-run planning without making write requests', async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                firebase: { projectId: 'my-project', serviceAccountPath: '/fake/sa.json' }
+            }
+        });
+        mockResponses['GET /projects/my-project/sites/my-site'] = {
+            status: 200,
+            body: { name: 'projects/my-project/sites/my-site' }
+        };
+        const builder = new FirebaseHostingBuilder('my-site');
+        builder.source('./dist').domain('my-domain.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.siteId, 'my-site');
+        assert.strictEqual(result.url, 'https://my-domain.com');
+        const writeCalls = fetchCalls.filter(c => c.method !== 'GET');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('deploys new version and creates release when site exists', async () => {
+        mockResponses['GET /projects/my-project/sites/my-site'] = {
+            status: 200,
+            body: { name: 'projects/my-project/sites/my-site' }
+        };
+        mockResponses['POST /versions'] = {
+            status: 200,
+            body: { name: 'projects/my-project/sites/my-site/versions/v111' }
+        };
+        mockResponses['POST /versions/v111:populateFiles'] = {
+            status: 200,
+            body: {
+                uploadUrl: 'https://upload-firebasehosting.googleapis.com/upload/v111',
+                uploadRequiredHashes: ['mock-hash-index']
+            }
+        };
+        mockResponses['POST /upload/v111/mock-hash-index'] = {
+            status: 200,
+            body: {}
+        };
+        mockResponses['PATCH /versions/v111'] = {
+            status: 200,
+            body: { status: 'FINALIZED' }
+        };
+        mockResponses['POST /releases'] = {
+            status: 200,
+            body: { name: 'projects/my-project/sites/my-site/releases/r222' }
+        };
+        const builder = new FirebaseHostingBuilder('my-site');
+        builder.source('./dist');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.siteId, 'my-site');
+        assert.strictEqual(result.url, 'https://my-site.web.app');
+        const createVersionCall = fetchCalls.find(c => c.method === 'POST' && c.url.endsWith('/versions'));
+        assert.ok(createVersionCall);
+        const populateCall = fetchCalls.find(c => c.method === 'POST' && c.url.endsWith('/versions/v111:populateFiles'));
+        assert.ok(populateCall);
+        assert.deepStrictEqual(populateCall.body.files, {
+            '/index.html': '8bde9ea78d892f46c76f95e789dfe2000427a3fb3abff9afd8f6b31456703c1d'
+        });
+        const uploadCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/upload/v111/mock-hash-index'));
+        assert.ok(uploadCall);
+        assert.strictEqual(uploadCall.headers?.['Authorization'], 'Bearer fake-access-token');
+        const patchVersionCall = fetchCalls.find(c => c.method === 'PATCH' && c.url.endsWith('/versions/v111'));
+        assert.ok(patchVersionCall);
+        assert.deepStrictEqual(patchVersionCall.body, { status: 'FINALIZED' });
+        const releaseCall = fetchCalls.find(c => c.method === 'POST' && c.url.includes('/releases'));
+        assert.ok(releaseCall);
+    });
+});

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

@@ -13,3 +13,4 @@ export declare const Proxmox: {
     }) => void;
     VM: (name: string) => VMBuilder;
 };
+export * from "../../types/proxmox.js";

package/dist/providers/proxmox/index.js

@@ -8,3 +8,4 @@ export const Proxmox = {
     },
     VM: (name) => new VMBuilder(name),
 };
+export * from "../../types/proxmox.js";

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

@@ -55,7 +55,6 @@ export declare class VMBuilder extends BaseBuilder {
     private checkPort;
     private sshKeyPath;
     private runProvisioner;
-    private runShellScript;
     private runPuppet;
     private runAnsible;
 }