@prajwolkc/stk 0.1.0

package/dist/services/checker.d.ts

@@ -0,0 +1,10 @@
+export interface CheckResult {
+    name: string;
+    status: "healthy" | "degraded" | "down" | "skipped";
+    latency?: number;
+    detail?: string;
+}
+export type ServiceChecker = () => Promise<CheckResult>;
+export declare function runCheck(name: string, fn: () => Promise<{
+    detail?: string;
+}>): Promise<CheckResult>;

package/dist/services/checker.js

@@ -0,0 +1,20 @@
+export async function runCheck(name, fn) {
+    const start = Date.now();
+    try {
+        const result = await fn();
+        return {
+            name,
+            status: "healthy",
+            latency: Date.now() - start,
+            detail: result.detail,
+        };
+    }
+    catch (err) {
+        return {
+            name,
+            status: "down",
+            latency: Date.now() - start,
+            detail: err.message ?? String(err),
+        };
+    }
+}

package/dist/services/database.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkDatabase(): Promise<CheckResult>;

package/dist/services/database.js

@@ -0,0 +1,27 @@
+import { runCheck } from "./checker.js";
+export async function checkDatabase() {
+    const url = process.env.DATABASE_URL;
+    if (!url) {
+        return { name: "PostgreSQL", status: "skipped", detail: "DATABASE_URL not set" };
+    }
+    return runCheck("PostgreSQL", async () => {
+        // Parse host and port from DATABASE_URL to do a basic TCP connect check
+        // Full query check would require pg client — keeping deps minimal for now
+        const parsed = new URL(url);
+        const host = parsed.hostname;
+        const port = parseInt(parsed.port || "5432", 10);
+        const { createConnection } = await import("net");
+        await new Promise((resolve, reject) => {
+            const socket = createConnection({ host, port, timeout: 5000 }, () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on("error", reject);
+            socket.on("timeout", () => {
+                socket.destroy();
+                reject(new Error("connection timeout"));
+            });
+        });
+        return { detail: `${host}:${port} reachable` };
+    });
+}

package/dist/services/fly.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkFly(): Promise<CheckResult>;

package/dist/services/fly.js

@@ -0,0 +1,17 @@
+import { runCheck } from "./checker.js";
+export async function checkFly() {
+    const token = process.env.FLY_API_TOKEN;
+    if (!token) {
+        return { name: "Fly.io", status: "skipped", detail: "FLY_API_TOKEN not set" };
+    }
+    return runCheck("Fly.io", async () => {
+        const res = await fetch("https://api.machines.dev/v1/apps", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = (await res.json());
+        const apps = data.total_apps ?? data.length ?? 0;
+        return { detail: `${apps} app${apps !== 1 ? "s" : ""} found` };
+    });
+}

package/dist/services/mongodb.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkMongoDB(): Promise<CheckResult>;

package/dist/services/mongodb.js

@@ -0,0 +1,25 @@
+import { runCheck } from "./checker.js";
+export async function checkMongoDB() {
+    const url = process.env.MONGODB_URL ?? process.env.MONGO_URL;
+    if (!url) {
+        return { name: "MongoDB", status: "skipped", detail: "MONGODB_URL not set" };
+    }
+    return runCheck("MongoDB", async () => {
+        const parsed = new URL(url);
+        const host = parsed.hostname;
+        const port = parseInt(parsed.port || "27017", 10);
+        const { createConnection } = await import("net");
+        await new Promise((resolve, reject) => {
+            const socket = createConnection({ host, port, timeout: 5000 }, () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on("error", reject);
+            socket.on("timeout", () => {
+                socket.destroy();
+                reject(new Error("connection timeout"));
+            });
+        });
+        return { detail: `${host}:${port} reachable` };
+    });
+}

package/dist/services/r2.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkR2(): Promise<CheckResult>;

package/dist/services/r2.js

@@ -0,0 +1,20 @@
+import { runCheck } from "./checker.js";
+export async function checkR2() {
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    if (!accountId || !apiToken) {
+        return {
+            name: "R2 Storage",
+            status: "skipped",
+            detail: "CLOUDFLARE_ACCOUNT_ID or CLOUDFLARE_API_TOKEN not set",
+        };
+    }
+    return runCheck("R2 Storage", async () => {
+        const res = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/r2/buckets`, { headers: { Authorization: `Bearer ${apiToken}` } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const count = data.result?.length ?? 0;
+        return { detail: `${count} bucket${count !== 1 ? "s" : ""} accessible` };
+    });
+}

package/dist/services/railway.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkRailway(): Promise<CheckResult>;

package/dist/services/railway.js

@@ -0,0 +1,26 @@
+import { runCheck } from "./checker.js";
+const RAILWAY_API = "https://backboard.railway.com/graphql/v2";
+export async function checkRailway() {
+    const token = process.env.RAILWAY_API_TOKEN;
+    if (!token) {
+        return { name: "Railway API", status: "skipped", detail: "RAILWAY_API_TOKEN not set" };
+    }
+    return runCheck("Railway API", async () => {
+        const res = await fetch(RAILWAY_API, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: `{ me { name email } }`,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        if (data.errors)
+            throw new Error(data.errors[0].message);
+        return { detail: `logged in as ${data.data.me.name}` };
+    });
+}

package/dist/services/redis.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkRedis(): Promise<CheckResult>;

package/dist/services/redis.js

@@ -0,0 +1,34 @@
+import { runCheck } from "./checker.js";
+export async function checkRedis() {
+    const url = process.env.REDIS_URL;
+    if (!url) {
+        return { name: "Redis", status: "skipped", detail: "REDIS_URL not set" };
+    }
+    return runCheck("Redis", async () => {
+        const parsed = new URL(url);
+        const host = parsed.hostname;
+        const port = parseInt(parsed.port || "6379", 10);
+        const { createConnection } = await import("net");
+        await new Promise((resolve, reject) => {
+            const socket = createConnection({ host, port, timeout: 5000 }, () => {
+                // Send PING, expect +PONG
+                socket.write("PING\r\n");
+                socket.once("data", (data) => {
+                    socket.destroy();
+                    if (data.toString().includes("+PONG")) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error("unexpected response: " + data.toString().trim()));
+                    }
+                });
+            });
+            socket.on("error", reject);
+            socket.on("timeout", () => {
+                socket.destroy();
+                reject(new Error("connection timeout"));
+            });
+        });
+        return { detail: `${host}:${port} responding` };
+    });
+}

package/dist/services/registry.d.ts

@@ -0,0 +1,4 @@
+import type { CheckResult } from "./checker.js";
+export type HealthChecker = () => Promise<CheckResult>;
+export declare function getChecker(service: string): HealthChecker | null;
+export declare function allCheckerNames(): string[];

package/dist/services/registry.js

@@ -0,0 +1,37 @@
+import { checkRailway } from "./railway.js";
+import { checkDatabase } from "./database.js";
+import { checkRedis } from "./redis.js";
+import { checkVercel } from "./vercel.js";
+import { checkR2 } from "./r2.js";
+import { checkStripe } from "./stripe.js";
+import { checkFly } from "./fly.js";
+import { checkRender } from "./render.js";
+import { checkSupabase } from "./supabase.js";
+import { checkAWS } from "./aws.js";
+import { checkMongoDB } from "./mongodb.js";
+/**
+ * Registry mapping service names to their health check functions.
+ * New services just need to be added here.
+ */
+const registry = {
+    // Deploy providers
+    railway: checkRailway,
+    vercel: checkVercel,
+    fly: checkFly,
+    render: checkRender,
+    aws: checkAWS,
+    // Databases
+    database: checkDatabase,
+    mongodb: checkMongoDB,
+    redis: checkRedis,
+    supabase: checkSupabase,
+    // Storage & billing
+    r2: checkR2,
+    stripe: checkStripe,
+};
+export function getChecker(service) {
+    return registry[service] ?? null;
+}
+export function allCheckerNames() {
+    return Object.keys(registry);
+}

package/dist/services/render.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkRender(): Promise<CheckResult>;

package/dist/services/render.js

@@ -0,0 +1,19 @@
+import { runCheck } from "./checker.js";
+export async function checkRender() {
+    const token = process.env.RENDER_API_KEY;
+    if (!token) {
+        return { name: "Render", status: "skipped", detail: "RENDER_API_KEY not set" };
+    }
+    return runCheck("Render", async () => {
+        const res = await fetch("https://api.render.com/v1/services?limit=1", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = (await res.json());
+        const svc = data[0]?.service;
+        if (!svc)
+            return { detail: "no services found" };
+        return { detail: `${svc.name} — ${svc.suspended === "not_suspended" ? "running" : svc.suspended}` };
+    });
+}

package/dist/services/stripe.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkStripe(): Promise<CheckResult>;

package/dist/services/stripe.js

@@ -0,0 +1,21 @@
+import { runCheck } from "./checker.js";
+export async function checkStripe() {
+    const key = process.env.STRIPE_SECRET_KEY;
+    if (!key) {
+        return { name: "Stripe", status: "skipped", detail: "STRIPE_SECRET_KEY not set" };
+    }
+    return runCheck("Stripe", async () => {
+        const res = await fetch("https://api.stripe.com/v1/balance", {
+            headers: { Authorization: `Bearer ${key}` },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const mode = key.startsWith("sk_live") ? "live" : "test";
+        const available = data.available?.[0];
+        const detail = available
+            ? `${mode} mode — balance: ${(available.amount / 100).toFixed(2)} ${available.currency.toUpperCase()}`
+            : `${mode} mode — API reachable`;
+        return { detail };
+    });
+}

package/dist/services/supabase.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkSupabase(): Promise<CheckResult>;

package/dist/services/supabase.js

@@ -0,0 +1,24 @@
+import { runCheck } from "./checker.js";
+export async function checkSupabase() {
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_KEY ?? process.env.SUPABASE_ANON_KEY;
+    if (!url || !key) {
+        return {
+            name: "Supabase",
+            status: "skipped",
+            detail: "SUPABASE_URL or SUPABASE_SERVICE_KEY not set",
+        };
+    }
+    return runCheck("Supabase", async () => {
+        // Hit the REST health endpoint
+        const res = await fetch(`${url}/rest/v1/`, {
+            headers: {
+                apikey: key,
+                Authorization: `Bearer ${key}`,
+            },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        return { detail: "API reachable" };
+    });
+}

package/dist/services/vercel.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkVercel(): Promise<CheckResult>;

package/dist/services/vercel.js

@@ -0,0 +1,35 @@
+import { runCheck } from "./checker.js";
+export async function checkVercel() {
+    const token = process.env.VERCEL_TOKEN;
+    if (!token) {
+        return { name: "Vercel", status: "skipped", detail: "VERCEL_TOKEN not set" };
+    }
+    return runCheck("Vercel", async () => {
+        // Get latest deployment
+        const res = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const dep = data.deployments?.[0];
+        if (!dep)
+            return { detail: "no deployments found" };
+        const ago = timeSince(new Date(dep.created));
+        const state = dep.readyState ?? dep.state ?? "unknown";
+        return { detail: `last deploy: ${state} (${ago} ago)` };
+    });
+}
+function timeSince(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,8 @@
+import type { StkConfig } from "../lib/config.js";
+export interface Template {
+    name: string;
+    description: string;
+    config: StkConfig;
+}
+export declare const templates: Record<string, Template>;
+export declare function listTemplates(): string[];

package/dist/templates/index.js

@@ -0,0 +1,105 @@
+export const templates = {
+    saas: {
+        name: "SaaS Starter",
+        description: "Full SaaS stack — Vercel frontend, Railway backend, PostgreSQL, Redis, Stripe billing, R2 storage",
+        config: {
+            name: "my-saas",
+            services: {
+                vercel: true,
+                railway: true,
+                database: true,
+                redis: true,
+                stripe: true,
+                r2: true,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["vercel", "railway"],
+            },
+        },
+    },
+    api: {
+        name: "API Service",
+        description: "Backend API — Railway or Render, PostgreSQL, Redis cache",
+        config: {
+            name: "my-api",
+            services: {
+                railway: true,
+                database: true,
+                redis: true,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["railway"],
+            },
+        },
+    },
+    fullstack: {
+        name: "Fullstack App",
+        description: "Vercel + Railway + Supabase with auth and storage built-in",
+        config: {
+            name: "my-app",
+            services: {
+                vercel: true,
+                railway: true,
+                supabase: true,
+                stripe: true,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["vercel", "railway"],
+            },
+        },
+    },
+    static: {
+        name: "Static / Jamstack",
+        description: "Vercel-only static site with optional Stripe for payments",
+        config: {
+            name: "my-site",
+            services: {
+                vercel: true,
+                stripe: false,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["vercel"],
+            },
+        },
+    },
+    fly: {
+        name: "Fly.io Stack",
+        description: "Fly.io deploy, PostgreSQL, Redis — edge-first architecture",
+        config: {
+            name: "my-fly-app",
+            services: {
+                fly: true,
+                database: true,
+                redis: true,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["fly"],
+            },
+        },
+    },
+    aws: {
+        name: "AWS Stack",
+        description: "AWS infrastructure with PostgreSQL and Redis",
+        config: {
+            name: "my-aws-app",
+            services: {
+                aws: true,
+                database: true,
+                redis: true,
+                r2: false,
+            },
+            deploy: {
+                branch: "main",
+                providers: ["aws"],
+            },
+        },
+    },
+};
+export function listTemplates() {
+    return Object.keys(templates);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@prajwolkc/stk",
+  "version": "0.1.0",
+  "description": "One CLI to deploy, monitor, and debug your entire stack. Health checks, deploy watching, env sync, logs, and GitHub issues — all from one command.",
+  "type": "module",
+  "license": "MIT",
+  "author": "prajwolkc",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Harden43/stk"
+  },
+  "keywords": [
+    "cli",
+    "devops",
+    "deploy",
+    "monitoring",
+    "railway",
+    "vercel",
+    "fly",
+    "render",
+    "supabase",
+    "aws",
+    "stripe",
+    "health-check",
+    "infrastructure",
+    "developer-tools"
+  ],
+  "bin": {
+    "stk": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}