stage-ai 0.2.0 → 0.2.1

package/dist/commands/status.d.ts

@@ -0,0 +1,7 @@
+interface OutputOptions {
+    json?: boolean;
+    quiet?: boolean;
+    session: string;
+}
+export declare function status(_args: string[], options: OutputOptions): Promise<void>;
+export {};

package/dist/commands/status.js

@@ -0,0 +1,73 @@
+import { getStatus as getSessionStatus } from "../convex-client.js";
+import { error, output, dim, bold } from "../utils/output.js";
+import { EXIT_ERROR } from "../utils/exit-codes.js";
+export async function status(_args, options) {
+    const { session } = options;
+    try {
+        const result = await getSessionStatus(session);
+        if (!result || !result.session) {
+            error(`Session not found: ${session}`);
+            process.exit(EXIT_ERROR);
+        }
+        output(options, {
+            json: () => ({
+                sessionId: session,
+                ...result,
+            }),
+            quiet: () => {
+                // Just output error if any, or "ok"
+                if (result.render?.error) {
+                    process.stdout.write(result.render.error);
+                }
+                else {
+                    process.stdout.write("ok");
+                }
+            },
+            human: () => {
+                console.log();
+                console.log(bold("Session"), dim(session));
+                console.log();
+                if (result.render) {
+                    const status = result.render.error ? "❌ Error" : "✓ OK";
+                    console.log(bold("Status"), status);
+                    console.log(bold("Entry"), result.render.entry);
+                    console.log(bold("Version"), `v${result.render.version}`);
+                    if (result.render.renderedAt) {
+                        const ago = formatTimeAgo(result.render.renderedAt);
+                        console.log(bold("Rendered"), ago);
+                    }
+                    if (result.render.error) {
+                        console.log();
+                        console.log(bold("Error:"));
+                        console.log(dim("─".repeat(50)));
+                        console.log(result.render.error);
+                        console.log(dim("─".repeat(50)));
+                    }
+                }
+                else {
+                    console.log(bold("Status"), dim("Not rendered yet"));
+                }
+                console.log();
+                console.log(bold("Files"), `(${result.files.length})`);
+                for (const file of result.files) {
+                    console.log(`  ${file.path} ${dim(`v${file.version} ${file.size}b`)}`);
+                }
+                console.log();
+            },
+        });
+    }
+    catch (e) {
+        error(e.message);
+        process.exit(EXIT_ERROR);
+    }
+}
+function formatTimeAgo(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}

package/dist/convex-client.d.ts

@@ -43,6 +43,24 @@ export declare function getRenderState(sessionId: string): Promise<{
     entry: string;
     version: number;
 } | null>;
+export interface SessionStatus {
+    session: {
+        createdAt: number;
+        lastAccessedAt: number;
+    } | null;
+    render: {
+        entry: string;
+        version: number;
+        error: string | null;
+        renderedAt: number | null;
+    } | null;
+    files: Array<{
+        path: string;
+        version: number;
+        size: number;
+    }>;
+}
+export declare function getStatus(sessionId: string): Promise<SessionStatus>;
 export declare function createSnapshot(sessionId: string, name?: string): Promise<string>;
 export declare function getSnapshots(sessionId: string): Promise<Array<{
     name?: string;

package/dist/convex-client.js

@@ -124,6 +124,9 @@ export async function triggerRender(sessionId, entry) {
 export async function getRenderState(sessionId) {
     return await query("getRenderState", { sessionId });
 }
+export async function getStatus(sessionId) {
+    return await query("getStatus", { sessionId });
+}
 export async function createSnapshot(sessionId, name) {
     return await mutation("createSnapshot", { sessionId, name });
 }

package/dist/main.js

@@ -10,6 +10,7 @@ import { render } from "./commands/render.js";
 import { ls } from "./commands/ls.js";
 import { push } from "./commands/push.js";
 import { onboard } from "./commands/onboard.js";
+import { status } from "./commands/status.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 const program = new Command();
@@ -73,6 +74,14 @@ program
     const root = cmd.optsWithGlobals();
     await render(entry, { json: root.json, quiet: root.quiet, session: opts.session });
 });
+program
+    .command("status")
+    .description("Get session status including render state and errors")
+    .requiredOption("-s, --session <id>", "Session ID")
+    .action(async (opts, cmd) => {
+    const root = cmd.optsWithGlobals();
+    await status([], { json: root.json, quiet: root.quiet, session: opts.session });
+});
 program
     .command("ls [path]")
     .description("List files in session")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stage-ai",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CLI client for Stage — a sandboxed React runtime for AI-generated applications",
   "type": "module",
   "main": "dist/main.js",