@prajwolkc/stk 0.1.1 → 0.2.1

package/dist/commands/logs.js

@@ -1,142 +1,246 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
+import { loadConfig, enabledServices } from "../lib/config.js";
 export const logsCommand = new Command("logs")
-    .description("Tail Railway runtime logs locally")
+    .description("Tail logs from your deploy providers")
     .option("-n, --lines <count>", "number of recent lines to show", "50")
     .option("-f, --follow", "keep streaming new logs")
+    .option("-p, --provider <name>", "specific provider (railway, vercel, fly, render)")
     .action(async (opts) => {
-    const token = process.env.RAILWAY_API_TOKEN;
-    if (!token) {
-        console.log(chalk.red("  RAILWAY_API_TOKEN not set"));
+    const config = loadConfig();
+    const enabled = enabledServices(config);
+    const limit = parseInt(opts.lines, 10);
+    // Build list of available log providers
+    const providers = [];
+    if ((opts.provider === "railway" || (!opts.provider && enabled.includes("railway"))) &&
+        process.env.RAILWAY_API_TOKEN) {
+        providers.push(railwayProvider());
+    }
+    if ((opts.provider === "vercel" || (!opts.provider && enabled.includes("vercel"))) &&
+        process.env.VERCEL_TOKEN) {
+        providers.push(vercelProvider());
+    }
+    if ((opts.provider === "fly" || (!opts.provider && enabled.includes("fly"))) &&
+        process.env.FLY_API_TOKEN) {
+        providers.push(flyProvider());
+    }
+    if ((opts.provider === "render" || (!opts.provider && enabled.includes("render"))) &&
+        process.env.RENDER_API_KEY) {
+        providers.push(renderProvider());
+    }
+    if (providers.length === 0) {
+        console.log(chalk.red("\n  No log providers available."));
+        console.log(chalk.dim("  Configure railway, vercel, fly, or render in stk.config.json and set their tokens.\n"));
         process.exitCode = 1;
         return;
     }
-    const projectId = process.env.RAILWAY_PROJECT_ID;
-    const serviceId = process.env.RAILWAY_SERVICE_ID;
-    const deploymentId = process.env.RAILWAY_DEPLOYMENT_ID;
-    if (!deploymentId) {
-        // Try to get latest deployment
-        const spinner = ora("Fetching latest deployment...").start();
+    // Fetch logs from all providers
+    for (const provider of providers) {
+        const spinner = ora(`Fetching ${provider.name} logs...`).start();
         try {
-            const latestDeploymentId = await getLatestDeploymentId(token, projectId, serviceId);
-            if (latestDeploymentId) {
-                spinner.succeed(`Found deployment ${chalk.dim(latestDeploymentId.slice(0, 8))}`);
-                await fetchAndPrintLogs(token, latestDeploymentId, parseInt(opts.lines, 10));
-                if (opts.follow) {
-                    await followLogs(token, latestDeploymentId);
-                }
+            const logs = await provider.fetch(limit);
+            spinner.stop();
+            if (logs.length === 0) {
+                console.log(chalk.dim(`\n  ${provider.name}: no logs found\n`));
+                continue;
             }
-            else {
-                spinner.fail("No deployments found");
-                console.log(chalk.dim("  Set RAILWAY_PROJECT_ID and RAILWAY_SERVICE_ID, or RAILWAY_DEPLOYMENT_ID"));
+            console.log();
+            console.log(chalk.bold(`  ${provider.name} Logs`));
+            console.log(chalk.dim("  ─────────────────────────────────────────"));
+            for (const log of logs) {
+                printLogLine(log, provider.name);
             }
         }
         catch (err) {
-            spinner.fail(err.message);
+            spinner.fail(`${provider.name}: ${err.message}`);
         }
-        return;
     }
-    await fetchAndPrintLogs(token, deploymentId, parseInt(opts.lines, 10));
-    if (opts.follow) {
-        await followLogs(token, deploymentId);
+    // Follow mode — stream from first available provider
+    if (opts.follow && providers[0]) {
+        console.log(chalk.dim("\n  --- streaming (Ctrl+C to stop) ---\n"));
+        const provider = providers[0];
+        if (provider.follow) {
+            await provider.follow((log) => printLogLine(log, provider.name));
+        }
+        else {
+            console.log(chalk.dim(`  ${provider.name} does not support streaming`));
+        }
     }
+    console.log();
 });
-async function getLatestDeploymentId(token, projectId, serviceId) {
+// --- Railway ---
+function railwayProvider() {
+    const token = process.env.RAILWAY_API_TOKEN;
+    const projectId = process.env.RAILWAY_PROJECT_ID;
+    const serviceId = process.env.RAILWAY_SERVICE_ID;
+    return {
+        name: "Railway",
+        async fetch(limit) {
+            const deploymentId = await getLatestRailwayDeployment(token, projectId, serviceId);
+            if (!deploymentId)
+                return [];
+            const res = await fetch("https://backboard.railway.com/graphql/v2", {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    query: `{ deploymentLogs(deploymentId: "${deploymentId}", limit: ${limit}) { timestamp message severity } }`,
+                }),
+            });
+            const data = (await res.json());
+            return data.data?.deploymentLogs ?? [];
+        },
+        async follow(onLog) {
+            const deploymentId = await getLatestRailwayDeployment(token, projectId, serviceId);
+            if (!deploymentId)
+                return;
+            let lastTimestamp = new Date().toISOString();
+            while (true) {
+                await sleep(3000);
+                try {
+                    const res = await fetch("https://backboard.railway.com/graphql/v2", {
+                        method: "POST",
+                        headers: {
+                            Authorization: `Bearer ${token}`,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            query: `{ deploymentLogs(deploymentId: "${deploymentId}", limit: 20) { timestamp message severity } }`,
+                        }),
+                    });
+                    const data = (await res.json());
+                    for (const log of data.data?.deploymentLogs ?? []) {
+                        if (log.timestamp > lastTimestamp) {
+                            onLog(log);
+                            lastTimestamp = log.timestamp;
+                        }
+                    }
+                }
+                catch { /* retry */ }
+            }
+        },
+    };
+}
+async function getLatestRailwayDeployment(token, projectId, serviceId) {
     if (!projectId)
         return null;
-    const serviceFilter = serviceId
-        ? `serviceId: "${serviceId}",`
-        : "";
+    const serviceFilter = serviceId ? `serviceId: "${serviceId}",` : "";
     const res = await fetch("https://backboard.railway.com/graphql/v2", {
         method: "POST",
-        headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-        },
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
         body: JSON.stringify({
-            query: `{
-        deployments(
-          first: 1,
-          input: {
-            projectId: "${projectId}",
-            ${serviceFilter}
-          }
-        ) {
-          edges {
-            node { id status }
-          }
-        }
-      }`,
+            query: `{ deployments(first: 1, input: { projectId: "${projectId}", ${serviceFilter} }) { edges { node { id } } } }`,
         }),
     });
     const data = (await res.json());
     return data.data?.deployments?.edges?.[0]?.node?.id ?? null;
 }
-async function fetchAndPrintLogs(token, deploymentId, limit) {
-    const res = await fetch("https://backboard.railway.com/graphql/v2", {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
+// --- Vercel ---
+function vercelProvider() {
+    const token = process.env.VERCEL_TOKEN;
+    return {
+        name: "Vercel",
+        async fetch(limit) {
+            // Get latest deployment, then its build logs
+            const depRes = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const depData = (await depRes.json());
+            const dep = depData.deployments?.[0];
+            if (!dep)
+                return [];
+            const logRes = await fetch(`https://api.vercel.com/v2/deployments/${dep.uid}/events`, { headers: { Authorization: `Bearer ${token}` } });
+            const events = (await logRes.json());
+            if (!Array.isArray(events))
+                return [];
+            return events
+                .filter((e) => e.type === "stdout" || e.type === "stderr")
+                .slice(-limit)
+                .map((e) => ({
+                timestamp: new Date(e.created).toISOString(),
+                message: e.payload?.text ?? e.text ?? "",
+                severity: e.type === "stderr" ? "ERROR" : "INFO",
+            }));
         },
-        body: JSON.stringify({
-            query: `{
-        deploymentLogs(deploymentId: "${deploymentId}", limit: ${limit}) {
-          timestamp
-          message
-          severity
-        }
-      }`,
-        }),
-    });
-    const data = (await res.json());
-    const logs = data.data?.deploymentLogs ?? [];
-    if (logs.length === 0) {
-        console.log(chalk.dim("  No logs found"));
-        return;
-    }
-    for (const log of logs) {
-        printLogLine(log);
-    }
+    };
 }
-async function followLogs(token, deploymentId) {
-    console.log(chalk.dim("\n  --- streaming (Ctrl+C to stop) ---\n"));
-    let lastTimestamp = new Date().toISOString();
-    while (true) {
-        await sleep(3000);
-        try {
-            const res = await fetch("https://backboard.railway.com/graphql/v2", {
+// --- Fly.io ---
+function flyProvider() {
+    const token = process.env.FLY_API_TOKEN;
+    const app = process.env.FLY_APP_NAME;
+    return {
+        name: "Fly.io",
+        async fetch(limit) {
+            if (!app) {
+                throw new Error("FLY_APP_NAME not set");
+            }
+            const res = await fetch("https://api.fly.io/graphql", {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${token}`,
                     "Content-Type": "application/json",
                 },
                 body: JSON.stringify({
-                    query: `{
-            deploymentLogs(deploymentId: "${deploymentId}", limit: 20, filter: "${lastTimestamp}") {
-              timestamp
-              message
-              severity
+                    query: `query {
+            app(name: "${app}") {
+              currentRelease { status createdAt }
             }
           }`,
                 }),
             });
             const data = (await res.json());
-            const logs = data.data?.deploymentLogs ?? [];
-            for (const log of logs) {
-                if (log.timestamp > lastTimestamp) {
-                    printLogLine(log);
-                    lastTimestamp = log.timestamp;
-                }
-            }
-        }
-        catch {
-            // retry silently
-        }
-    }
+            const release = data.data?.app?.currentRelease;
+            if (!release)
+                return [];
+            // Fly doesn't have a simple log fetch API via GraphQL
+            // Return release info as a log line
+            return [
+                {
+                    timestamp: release.createdAt,
+                    message: `Current release: ${release.status}`,
+                    severity: "INFO",
+                },
+            ];
+        },
+    };
+}
+// --- Render ---
+function renderProvider() {
+    const token = process.env.RENDER_API_KEY;
+    return {
+        name: "Render",
+        async fetch(logLimit) {
+            // Get first service
+            const svcRes = await fetch("https://api.render.com/v1/services?limit=1", {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const services = (await svcRes.json());
+            const svc = services[0]?.service;
+            if (!svc)
+                return [];
+            // Get deploys for the service
+            const depRes = await fetch(`https://api.render.com/v1/services/${svc.id}/deploys?limit=1`, { headers: { Authorization: `Bearer ${token}` } });
+            const deploys = (await depRes.json());
+            const deploy = deploys[0]?.deploy;
+            if (!deploy)
+                return [];
+            // Get logs for the deploy
+            const logRes = await fetch(`https://api.render.com/v1/services/${svc.id}/deploys/${deploy.id}/logs`, { headers: { Authorization: `Bearer ${token}` } });
+            const logs = (await logRes.json());
+            if (!Array.isArray(logs))
+                return [];
+            return logs.slice(-logLimit).map((l) => ({
+                timestamp: l.timestamp ?? new Date().toISOString(),
+                message: l.message ?? l.text ?? String(l),
+                severity: "INFO",
+            }));
+        },
+    };
 }
-function printLogLine(log) {
+function printLogLine(log, provider) {
     const time = chalk.dim(new Date(log.timestamp).toLocaleTimeString());
     const severity = log.severity?.toUpperCase() ?? "INFO";
     const sevColor = severity === "ERROR"
@@ -144,7 +248,8 @@ function printLogLine(log) {
         : severity === "WARN"
             ? chalk.yellow
             : chalk.dim;
-    console.log(`  ${time}  ${sevColor(severity.padEnd(5))}  ${log.message}`);
+    const tag = chalk.dim(`[${provider.toLowerCase()}]`);
+    console.log(`  ${time} ${tag}  ${sevColor(severity.padEnd(5))}  ${log.message}`);
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/index.js

@@ -7,11 +7,12 @@ import { deployCommand } from "./commands/deploy.js";
 import { envCommand } from "./commands/env.js";
 import { logsCommand } from "./commands/logs.js";
 import { todoCommand } from "./commands/todo.js";
+import { doctorCommand } from "./commands/doctor.js";
 const program = new Command();
 program
     .name("stk")
     .description("One CLI to deploy, monitor, and debug your entire stack.")
-    .version("0.1.0");
+    .version("0.2.0");
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
 program.addCommand(healthCommand);
@@ -19,4 +20,5 @@ program.addCommand(deployCommand);
 program.addCommand(envCommand);
 program.addCommand(logsCommand);
 program.addCommand(todoCommand);
+program.addCommand(doctorCommand);
 program.parse();

package/dist/lib/output.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared output helper. When --json is passed, commands collect data
+ * and call jsonOutput() instead of console.log with chalk.
+ */
+export declare function setJsonMode(enabled: boolean): void;
+export declare function isJsonMode(): boolean;
+export declare function jsonOutput(data: unknown): void;

package/dist/lib/output.js

@@ -0,0 +1,14 @@
+/**
+ * Shared output helper. When --json is passed, commands collect data
+ * and call jsonOutput() instead of console.log with chalk.
+ */
+let jsonMode = false;
+export function setJsonMode(enabled) {
+    jsonMode = enabled;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+export function jsonOutput(data) {
+    console.log(JSON.stringify(data, null, 2));
+}

package/dist/lib/plugins.d.ts

@@ -0,0 +1,40 @@
+import type { CheckResult } from "../services/checker.js";
+export interface StkPlugin {
+    name: string;
+    version?: string;
+    services?: Record<string, PluginService>;
+}
+export interface PluginService {
+    name: string;
+    envVars: string[];
+    healthCheck: () => Promise<CheckResult>;
+}
+/**
+ * Load plugins from .stk/plugins/ directory.
+ *
+ * Each plugin is a .js or .mjs file that exports a StkPlugin:
+ *
+ * ```js
+ * // .stk/plugins/my-service.mjs
+ * export default {
+ *   name: "my-plugin",
+ *   services: {
+ *     myservice: {
+ *       name: "My Service",
+ *       envVars: ["MY_SERVICE_TOKEN"],
+ *       healthCheck: async () => {
+ *         const token = process.env.MY_SERVICE_TOKEN;
+ *         if (!token) return { name: "My Service", status: "skipped", detail: "MY_SERVICE_TOKEN not set" };
+ *         // ... check logic
+ *         return { name: "My Service", status: "healthy", detail: "connected" };
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export declare function loadPlugins(): Promise<StkPlugin[]>;
+/**
+ * Collect all plugin health checkers into a flat record.
+ */
+export declare function getPluginCheckers(): Promise<Record<string, () => Promise<CheckResult>>>;

package/dist/lib/plugins.js

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync } from "fs";
+import { resolve, join } from "path";
+import { pathToFileURL } from "url";
+const PLUGIN_DIR = ".stk/plugins";
+/**
+ * Load plugins from .stk/plugins/ directory.
+ *
+ * Each plugin is a .js or .mjs file that exports a StkPlugin:
+ *
+ * ```js
+ * // .stk/plugins/my-service.mjs
+ * export default {
+ *   name: "my-plugin",
+ *   services: {
+ *     myservice: {
+ *       name: "My Service",
+ *       envVars: ["MY_SERVICE_TOKEN"],
+ *       healthCheck: async () => {
+ *         const token = process.env.MY_SERVICE_TOKEN;
+ *         if (!token) return { name: "My Service", status: "skipped", detail: "MY_SERVICE_TOKEN not set" };
+ *         // ... check logic
+ *         return { name: "My Service", status: "healthy", detail: "connected" };
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export async function loadPlugins() {
+    const pluginDir = resolve(process.cwd(), PLUGIN_DIR);
+    if (!existsSync(pluginDir))
+        return [];
+    const plugins = [];
+    const files = readdirSync(pluginDir).filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+    for (const file of files) {
+        try {
+            const filePath = join(pluginDir, file);
+            const fileUrl = pathToFileURL(filePath).href;
+            const mod = await import(fileUrl);
+            const plugin = mod.default ?? mod;
+            if (plugin.name && plugin.services) {
+                plugins.push(plugin);
+            }
+        }
+        catch {
+            // Skip invalid plugins silently
+        }
+    }
+    return plugins;
+}
+/**
+ * Collect all plugin health checkers into a flat record.
+ */
+export async function getPluginCheckers() {
+    const plugins = await loadPlugins();
+    const checkers = {};
+    for (const plugin of plugins) {
+        if (!plugin.services)
+            continue;
+        for (const [key, svc] of Object.entries(plugin.services)) {
+            checkers[key] = svc.healthCheck;
+        }
+    }
+    return checkers;
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * stk MCP Server
+ *
+ * Exposes your entire infrastructure as tools for Claude Code.
+ * Claude can check health, read logs, deploy, manage issues, and diagnose
+ * problems — all through structured tool calls.
+ */
+export {};