Add icon and APK update support in admin app list

zeeshanbage · zeeshanbage · commit d4af20c9a3b9 · 2026-03-29T13:09:41.000+05:30
diff --git a/webapp/src/app/api/update-apk/route.ts b/webapp/src/app/api/update-apk/route.ts
@@ -0,0 +1,190 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createClient } from "@supabase/supabase-js";
+import { createWriteStream, createReadStream } from "fs";
+import { unlink, stat } from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import Busboy from "busboy";
+import { Readable } from "stream";
+
+const githubApiRequest = async (endpoint: string, options: RequestInit = {}) => {
+    const githubToken = process.env.GITHUB_TOKEN;
+    if (!githubToken) throw new Error("Missing GITHUB_TOKEN");
+
+    const res = await fetch(`https://api.github.com${endpoint}`, {
+        ...options,
+        headers: {
+            Accept: "application/vnd.github.v3+json",
+            Authorization: `token ${githubToken}`,
+            "X-GitHub-Api-Version": "2022-11-28",
+            ...options.headers,
+        },
+    });
+
+    if (!res.ok) {
+        const errorText = await res.text();
+        throw new Error(`GitHub API Error (${res.status}): ${errorText}`);
+    }
+    return res.json();
+};
+
+function getSupabaseAdmin() {
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!supabaseUrl || !supabaseServiceKey) {
+        throw new Error("Missing Supabase credentials.");
+    }
+    return createClient(supabaseUrl, supabaseServiceKey, {
+        auth: { autoRefreshToken: false, persistSession: false },
+    });
+}
+
+export async function POST(request: NextRequest) {
+    const githubRepo = "zeeshanbage/ZeeshanAppHub";
+
+    if (!request.body) {
+        return NextResponse.json({ error: "No request body." }, { status: 400 });
+    }
+
+    const contentType = request.headers.get("content-type") || "";
+    const bb = Busboy({ headers: { "content-type": contentType } });
+
+    const fields: Record<string, string> = {};
+    let tempApkPath = "";
+
+    const parsePromise = new Promise<void>((resolve, reject) => {
+        bb.on("field", (name, val) => {
+            fields[name] = val;
+        });
+
+        bb.on("file", (name, file) => {
+            if (name === "apk") {
+                const tempFileName = `update_${Date.now()}.apk`;
+                tempApkPath = path.join(os.tmpdir(), tempFileName);
+
+                const writeStream = createWriteStream(tempApkPath);
+                file.pipe(writeStream);
+
+                file.on("error", reject);
+                writeStream.on("error", reject);
+            } else {
+                file.resume();
+            }
+        });
+
+        bb.on("finish", resolve);
+        bb.on("error", reject);
+    });
+
+    try {
+        const nodeStream = Readable.fromWeb(request.body as any);
+        nodeStream.pipe(bb);
+        await parsePromise;
+    } catch {
+        return NextResponse.json({ error: "Failed to parse form data." }, { status: 400 });
+    }
+
+    try {
+        const { appId, appName, newVersion, oldApkUrl } = fields;
+        if (!appId || !appName || !newVersion || !tempApkPath) {
+            throw new Error("Missing required fields (appId, appName, newVersion) or APK file.");
+        }
+
+        const supabase = getSupabaseAdmin();
+        const sanitize = (s: string) => s.replace(/[^a-zA-Z0-9-]/g, "");
+        const releaseTag = `${sanitize(appName)}-v${sanitize(newVersion)}`;
+        const apkFileName = `${sanitize(appName)}_v${sanitize(newVersion)}.apk`;
+
+        // 1. Delete old GitHub Release (best-effort)
+        if (oldApkUrl && oldApkUrl.includes("github.com")) {
+            try {
+                const urlParts = oldApkUrl.split("/");
+                const downloadIndex = urlParts.indexOf("download");
+                if (downloadIndex !== -1 && urlParts[downloadIndex + 1]) {
+                    const oldTag = urlParts[downloadIndex + 1];
+                    const githubToken = process.env.GITHUB_TOKEN;
+
+                    const releaseData = await githubApiRequest(`/repos/${githubRepo}/releases/tags/${oldTag}`);
+
+                    await fetch(`https://api.github.com/repos/${githubRepo}/releases/${releaseData.id}`, {
+                        method: "DELETE",
+                        headers: {
+                            Authorization: `token ${githubToken}`,
+                            "X-GitHub-Api-Version": "2022-11-28",
+                        },
+                    });
+
+                    await fetch(`https://api.github.com/repos/${githubRepo}/git/refs/tags/${oldTag}`, {
+                        method: "DELETE",
+                        headers: {
+                            Authorization: `token ${githubToken}`,
+                            "X-GitHub-Api-Version": "2022-11-28",
+                        },
+                    });
+
+                    console.log(`Deleted old GitHub Release: ${oldTag}`);
+                }
+            } catch (e: any) {
+                console.warn("Old release cleanup failed:", e.message);
+            }
+        }
+
+        // 2. Create new GitHub Release
+        const releaseData = await githubApiRequest(`/repos/${githubRepo}/releases`, {
+            method: "POST",
+            body: JSON.stringify({
+                tag_name: releaseTag,
+                name: `${appName} - Version ${newVersion}`,
+                body: `Updated release for ${appName} v${newVersion}.`,
+                draft: false,
+                prerelease: false,
+                generate_release_notes: false,
+            }),
+        });
+
+        // 3. Upload APK to GitHub via stream
+        const uploadUrl = releaseData.upload_url.replace("{?name,label}", `?name=${apkFileName}`);
+        const githubToken = process.env.GITHUB_TOKEN;
+
+        const fileSize = await stat(tempApkPath).then(s => s.size);
+        const fileStream = createReadStream(tempApkPath);
+        const webStream = Readable.toWeb(fileStream);
+
+        const uploadRes = await fetch(uploadUrl, {
+            method: "POST",
+            headers: {
+                Accept: "application/vnd.github.v3+json",
+                Authorization: `token ${githubToken}`,
+                "Content-Type": "application/vnd.android.package-archive",
+                "X-GitHub-Api-Version": "2022-11-28",
+                "Content-Length": String(fileSize),
+            },
+            body: webStream as any,
+            duplex: "half",
+        } as any);
+
+        if (!uploadRes.ok) {
+            const errText = await uploadRes.text();
+            throw new Error(`APK upload to GitHub failed: ${errText}`);
+        }
+
+        const assetData = await uploadRes.json();
+        const newApkUrl = assetData.browser_download_url;
+
+        // 4. Update DB with new version and apk_url
+        const { error: dbErr } = await supabase
+            .from("apps")
+            .update({ version: newVersion, apk_url: newApkUrl })
+            .eq("id", appId);
+        if (dbErr) throw new Error(`DB update failed: ${dbErr.message}`);
+
+        return NextResponse.json({ success: true, apk_url: newApkUrl, version: newVersion });
+    } catch (error: any) {
+        console.error("Update APK Error:", error);
+        return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+    } finally {
+        if (tempApkPath) {
+            await unlink(tempApkPath).catch(() => {});
+        }
+    }
+}
diff --git a/webapp/src/app/api/update-icon/route.ts b/webapp/src/app/api/update-icon/route.ts
@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createClient } from "@supabase/supabase-js";
+import Busboy from "busboy";
+import { Readable } from "stream";
+
+function getSupabaseAdmin() {
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!supabaseUrl || !supabaseServiceKey) {
+        throw new Error("Missing Supabase credentials.");
+    }
+    return createClient(supabaseUrl, supabaseServiceKey, {
+        auth: { autoRefreshToken: false, persistSession: false },
+    });
+}
+
+export async function POST(request: NextRequest) {
+    if (!request.body) {
+        return NextResponse.json({ error: "No request body." }, { status: 400 });
+    }
+
+    const contentType = request.headers.get("content-type") || "";
+    const bb = Busboy({ headers: { "content-type": contentType } });
+
+    const fields: Record<string, string> = {};
+    let iconChunks: Buffer[] = [];
+
+    const parsePromise = new Promise<void>((resolve, reject) => {
+        bb.on("field", (name, val) => {
+            fields[name] = val;
+        });
+
+        bb.on("file", (name, file) => {
+            if (name === "icon") {
+                file.on("data", (chunk: Buffer) => {
+                    iconChunks.push(chunk);
+                });
+            } else {
+                file.resume();
+            }
+        });
+
+        bb.on("finish", resolve);
+        bb.on("error", reject);
+    });
+
+    try {
+        const nodeStream = Readable.fromWeb(request.body as any);
+        nodeStream.pipe(bb);
+        await parsePromise;
+    } catch {
+        return NextResponse.json({ error: "Failed to parse form data." }, { status: 400 });
+    }
+
+    try {
+        const { appId, oldIconUrl } = fields;
+        if (!appId || iconChunks.length === 0) {
+            return NextResponse.json({ error: "Missing appId or icon file." }, { status: 400 });
+        }
+
+        const supabase = getSupabaseAdmin();
+        const iconBuffer = Buffer.concat(iconChunks);
+        iconChunks = []; // free memory
+
+        // 1. Delete old icon from Supabase Storage (best-effort)
+        if (oldIconUrl && oldIconUrl.includes("/icons/")) {
+            try {
+                const iconPath = oldIconUrl.split("/icons/")[1]?.split("?")[0];
+                if (iconPath) {
+                    await supabase.storage.from("icons").remove([iconPath]);
+                }
+            } catch (e) {
+                console.warn("Old icon cleanup failed:", e);
+            }
+        }
+
+        // 2. Upload new icon
+        const iconFileName = `${Date.now()}.png`;
+        const { error: uploadErr } = await supabase.storage
+            .from("icons")
+            .upload(iconFileName, iconBuffer, { upsert: false, contentType: "image/png" });
+        if (uploadErr) throw new Error(`Icon upload failed: ${uploadErr.message}`);
+
+        // 3. Get signed URL
+        const { data: signed, error: signErr } = await supabase.storage
+            .from("icons")
+            .createSignedUrl(iconFileName, 60 * 60 * 24 * 365 * 100);
+        if (signErr || !signed) throw new Error(`Icon sign failed: ${signErr?.message}`);
+
+        // 4. Update DB
+        const { error: dbErr } = await supabase
+            .from("apps")
+            .update({ icon_url: signed.signedUrl })
+            .eq("id", appId);
+        if (dbErr) throw new Error(`DB update failed: ${dbErr.message}`);
+
+        return NextResponse.json({ success: true, icon_url: signed.signedUrl });
+    } catch (error: any) {
+        console.error("Update Icon Error:", error);
+        return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+    }
+}
diff --git a/webapp/src/components/AppList.tsx b/webapp/src/components/AppList.tsx
