@simonfestl/husky-cli 1.27.1 → 1.29.1

package/dist/commands/task.js

@@ -346,6 +346,7 @@ taskCommand
     .requiredOption("--worker <hostname>", "Target worker hostname (e.g., worker-1)")
     .option("--priority <level>", "Priority: low, normal, high, urgent", "normal")
     .option("--instructions <text>", "Additional instructions for the worker")
+    .option("--no-vm", "Don't create preemptible VM if worker is not running")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
     const config = ensureConfig();
@@ -361,6 +362,7 @@ taskCommand
             targetHostname: options.worker,
             priority: options.priority,
             instructions: options.instructions,
+            ensureVM: options.vm !== false, // --no-vm sets options.vm to false
         });
         if (options.json) {
             console.log(JSON.stringify(result, null, 2));
@@ -373,6 +375,11 @@ taskCommand
             if (options.instructions) {
                 console.log(`  Instructions: ${options.instructions.slice(0, 50)}...`);
             }
+            // Show VM info if a new VM was created
+            if (result.vm?.created) {
+                console.log(`\n  🖥️  Created preemptible VM: ${result.vm.name}`);
+                console.log(`      VM will be ready in ${result.vm.estimatedReadyIn}`);
+            }
             console.log(`\n  The worker-bridge on ${options.worker} will inject this task into OpenCode.`);
         }
     }

package/dist/lib/biz/gcs-upload.d.ts

@@ -0,0 +1,86 @@
+/**
+ * GCS Upload Client
+ *
+ * Uploads extracted invoice PDFs to Google Cloud Storage
+ *
+ * Structure:
+ * gs://husky-invoices/
+ * └── partners/
+ *     └── suppliers/
+ *         └── {sourceId}/                    # Firestore InvoiceSource doc ID
+ *             └── {extractedInvoiceId}.pdf   # Firestore ExtractedInvoice doc ID
+ */
+interface UploadResult {
+    success: boolean;
+    gcsUri?: string;
+    gcsPath?: string;
+    publicUrl?: string;
+    error?: string;
+}
+interface UploadOptions {
+    bucket?: string;
+    prefix?: string;
+    makePublic?: boolean;
+    metadata?: Record<string, string>;
+}
+/**
+ * GCS Upload Client for invoice PDFs
+ */
+export declare class GCSUploadClient {
+    private storage;
+    private bucketName;
+    constructor(bucketName?: string);
+    /**
+     * Upload a single file to GCS
+     */
+    uploadFile(localPath: string, options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Upload multiple files to GCS
+     */
+    uploadFiles(localPaths: string[], options?: UploadOptions): Promise<{
+        results: UploadResult[];
+        successCount: number;
+        failCount: number;
+    }>;
+    /**
+     * Upload invoice using Firestore IDs for path structure
+     * Path: partners/suppliers/{sourceId}/{invoiceId}.pdf
+     */
+    uploadInvoiceById(localPath: string, options: {
+        sourceId: string;
+        extractedInvoiceId: string;
+        metadata?: Record<string, string>;
+    }): Promise<UploadResult>;
+    /**
+     * Upload invoice with source name (legacy/fallback)
+     * Creates a temp ID if Firestore IDs not available
+     */
+    uploadInvoice(localPath: string, options: {
+        source: string;
+        orderNumber: string;
+        invoiceDate?: string;
+        sourceId?: string;
+        extractedInvoiceId?: string;
+    }): Promise<UploadResult>;
+    /**
+     * List files in bucket with prefix
+     */
+    listFiles(prefix?: string): Promise<string[]>;
+    /**
+     * Check if bucket exists and is accessible
+     */
+    checkAccess(): Promise<{
+        accessible: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get signed URL for temporary access to a file
+     */
+    getSignedUrl(gcsPath: string, expiresInMinutes?: number): Promise<string | null>;
+    getBucketName(): string;
+}
+/**
+ * Create GCS upload client from config
+ */
+export declare function createGCSClient(bucketName?: string): GCSUploadClient;
+export default GCSUploadClient;

package/dist/lib/biz/gcs-upload.js

@@ -0,0 +1,189 @@
+/**
+ * GCS Upload Client
+ *
+ * Uploads extracted invoice PDFs to Google Cloud Storage
+ *
+ * Structure:
+ * gs://husky-invoices/
+ * └── partners/
+ *     └── suppliers/
+ *         └── {sourceId}/                    # Firestore InvoiceSource doc ID
+ *             └── {extractedInvoiceId}.pdf   # Firestore ExtractedInvoice doc ID
+ */
+import { Storage } from "@google-cloud/storage";
+import * as fs from "fs";
+import * as path from "path";
+import { getConfig } from "../../commands/config.js";
+// Default bucket for invoice PDFs
+const DEFAULT_BUCKET = "husky-invoices";
+// Base path structure
+const PARTNERS_SUPPLIERS_PATH = "partners/suppliers";
+/**
+ * GCS Upload Client for invoice PDFs
+ */
+export class GCSUploadClient {
+    storage;
+    bucketName;
+    constructor(bucketName) {
+        const config = getConfig();
+        this.bucketName = bucketName || config.gcsBucket || process.env.GCS_INVOICE_BUCKET || DEFAULT_BUCKET;
+        // Initialize storage client
+        // Uses Application Default Credentials (ADC) in Cloud Run
+        // Or GOOGLE_APPLICATION_CREDENTIALS env var locally
+        this.storage = new Storage();
+    }
+    /**
+     * Upload a single file to GCS
+     */
+    async uploadFile(localPath, options = {}) {
+        try {
+            if (!fs.existsSync(localPath)) {
+                return { success: false, error: `File not found: ${localPath}` };
+            }
+            const bucket = this.storage.bucket(options.bucket || this.bucketName);
+            const filename = path.basename(localPath);
+            const destination = options.prefix
+                ? `${options.prefix}/${filename}`
+                : filename;
+            const uploadOptions = {
+                destination,
+            };
+            if (options.metadata) {
+                uploadOptions.metadata = { metadata: options.metadata };
+            }
+            await bucket.upload(localPath, uploadOptions);
+            const gcsUri = `gs://${this.bucketName}/${destination}`;
+            let publicUrl;
+            if (options.makePublic) {
+                const file = bucket.file(destination);
+                await file.makePublic();
+                publicUrl = `https://storage.googleapis.com/${this.bucketName}/${destination}`;
+            }
+            return { success: true, gcsUri, gcsPath: destination, publicUrl };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Upload multiple files to GCS
+     */
+    async uploadFiles(localPaths, options = {}) {
+        const results = [];
+        let successCount = 0;
+        let failCount = 0;
+        for (const localPath of localPaths) {
+            const result = await this.uploadFile(localPath, options);
+            results.push(result);
+            if (result.success) {
+                successCount++;
+            }
+            else {
+                failCount++;
+            }
+        }
+        return { results, successCount, failCount };
+    }
+    /**
+     * Upload invoice using Firestore IDs for path structure
+     * Path: partners/suppliers/{sourceId}/{invoiceId}.pdf
+     */
+    async uploadInvoiceById(localPath, options) {
+        const prefix = `${PARTNERS_SUPPLIERS_PATH}/${options.sourceId}`;
+        const filename = `${options.extractedInvoiceId}.pdf`;
+        return this.uploadFile(localPath, {
+            prefix,
+            metadata: {
+                sourceId: options.sourceId,
+                extractedInvoiceId: options.extractedInvoiceId,
+                uploadedAt: new Date().toISOString(),
+                ...options.metadata,
+            },
+        });
+    }
+    /**
+     * Upload invoice with source name (legacy/fallback)
+     * Creates a temp ID if Firestore IDs not available
+     */
+    async uploadInvoice(localPath, options) {
+        // If we have Firestore IDs, use the ID-based path
+        if (options.sourceId && options.extractedInvoiceId) {
+            return this.uploadInvoiceById(localPath, {
+                sourceId: options.sourceId,
+                extractedInvoiceId: options.extractedInvoiceId,
+                metadata: {
+                    sourceName: options.source,
+                    orderNumber: options.orderNumber,
+                    invoiceDate: options.invoiceDate || "",
+                },
+            });
+        }
+        // Fallback: use source name + order number as identifier
+        const tempId = `${options.source}-${options.orderNumber}-${Date.now()}`;
+        const prefix = `${PARTNERS_SUPPLIERS_PATH}/${options.source}`;
+        return this.uploadFile(localPath, {
+            prefix,
+            metadata: {
+                sourceName: options.source,
+                orderNumber: options.orderNumber,
+                invoiceDate: options.invoiceDate || "",
+                uploadedAt: new Date().toISOString(),
+                tempId,
+            },
+        });
+    }
+    /**
+     * List files in bucket with prefix
+     */
+    async listFiles(prefix) {
+        const bucket = this.storage.bucket(this.bucketName);
+        const [files] = await bucket.getFiles({ prefix });
+        return files.map((f) => f.name);
+    }
+    /**
+     * Check if bucket exists and is accessible
+     */
+    async checkAccess() {
+        try {
+            const bucket = this.storage.bucket(this.bucketName);
+            const [exists] = await bucket.exists();
+            if (!exists) {
+                return { accessible: false, error: `Bucket ${this.bucketName} does not exist` };
+            }
+            // Try to list files to verify permissions
+            await bucket.getFiles({ maxResults: 1 });
+            return { accessible: true };
+        }
+        catch (error) {
+            return { accessible: false, error: error.message };
+        }
+    }
+    /**
+     * Get signed URL for temporary access to a file
+     */
+    async getSignedUrl(gcsPath, expiresInMinutes = 60) {
+        try {
+            const bucket = this.storage.bucket(this.bucketName);
+            const file = bucket.file(gcsPath);
+            const [url] = await file.getSignedUrl({
+                action: "read",
+                expires: Date.now() + expiresInMinutes * 60 * 1000,
+            });
+            return url;
+        }
+        catch (error) {
+            console.error("Error generating signed URL:", error);
+            return null;
+        }
+    }
+    getBucketName() {
+        return this.bucketName;
+    }
+}
+/**
+ * Create GCS upload client from config
+ */
+export function createGCSClient(bucketName) {
+    return new GCSUploadClient(bucketName);
+}
+export default GCSUploadClient;

package/dist/lib/biz/index.d.ts

@@ -12,3 +12,8 @@ export * from './billbee-types.js';
 export * from './zendesk-types.js';
 export * from './seatable-types.js';
 export { GotessClient } from './gotess.js';
+export { ShopifyClient } from './shopify.js';
+export type { Order as ShopifyOrder, Customer as ShopifyCustomer, Product as ShopifyProduct, ShopMetrics, } from './shopify.js';
+export { SupplierFeedService } from './supplier-feed.js';
+export type { SupplierId, SupplierProduct, SupplierProductSearchResult, SyncStats, } from './supplier-feed.js';
+export * from './supplier-feed-types.js';

package/dist/lib/biz/index.js

@@ -10,3 +10,6 @@ export * from './billbee-types.js';
 export * from './zendesk-types.js';
 export * from './seatable-types.js';
 export { GotessClient } from './gotess.js';
+export { ShopifyClient } from './shopify.js';
+export { SupplierFeedService } from './supplier-feed.js';
+export * from './supplier-feed-types.js';

package/dist/lib/biz/invoice-extractor-registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Invoice Extractor Registry
+ *
+ * Registers available extractors and provides factory methods
+ */
+import { InvoiceExtractor } from "./invoice-extractor-types.js";
+/**
+ * Get an extractor by ID
+ */
+export declare function getExtractor(extractorId: string): InvoiceExtractor | null;
+/**
+ * Get all available extractor IDs
+ */
+export declare function getAvailableExtractorIds(): string[];
+/**
+ * Check if credentials are configured for an extractor
+ */
+export declare function hasCredentialsConfigured(extractorId: string): boolean;
+/**
+ * Get default output directory for invoices
+ */
+export declare function getDefaultInvoiceDir(): string;