npm - clawnify - Versions diffs - 0.1.1 - Mend

clawnify 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/chunk-6UAOYVZ6.js +325 -0
package/dist/chunk-6UAOYVZ6.js.map +1 -0
package/dist/cli-MDRNA6W2.js +741 -0
package/dist/cli-MDRNA6W2.js.map +1 -0
package/dist/index.js +11 -0
package/dist/index.js.map +1 -0
package/dist/mcp-JLE4IWRX.js +132 -0
package/dist/mcp-JLE4IWRX.js.map +1 -0
package/package.json +27 -0

package/dist/cli-MDRNA6W2.js ADDED Viewed

@@ -0,0 +1,741 @@
+#!/usr/bin/env node
+import {
+  OAUTH_AUTHORIZE_URL,
+  OAUTH_CLIENT_ID,
+  OAUTH_TOKEN_URL,
+  api,
+  createArchive,
+  generatePkce,
+  getEmailFromToken,
+  loadAuth,
+  pollUntilReady,
+  readManifest,
+  readProject,
+  saveAuth,
+  saveProject
+} from "./chunk-6UAOYVZ6.js";
+// src/cli.ts
+import { Command } from "commander";
+// src/commands/login.ts
+import crypto from "crypto";
+import http from "http";
+import readline from "readline";
+import open from "open";
+async function loginCommand() {
+  const { codeVerifier: verifier, codeChallenge: challenge } = generatePkce();
+  const state = crypto.randomBytes(16).toString("hex");
+  const port = 19823;
+  const redirectUri = `http://localhost:${port}/callback`;
+  const authUrl = new URL(OAUTH_AUTHORIZE_URL);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("scope", "openid email");
+  authUrl.searchParams.set("state", state);
+  const result = await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Timed out waiting for authorization."));
+    }, 5 * 60 * 1e3);
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Authorization denied.</h2><p>You can close this window.</p></body></html>"
+        );
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(`Authorization denied: ${error}`));
+        return;
+      }
+      if (!code || returnedState !== state) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Invalid callback.</h2></body></html>"
+        );
+        return;
+      }
+      try {
+        const tokenRes = await fetch(OAUTH_TOKEN_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            grant_type: "authorization_code",
+            code,
+            client_id: OAUTH_CLIENT_ID,
+            redirect_uri: redirectUri,
+            code_verifier: verifier
+          })
+        });
+        if (!tokenRes.ok) {
+          const err = await tokenRes.text();
+          throw new Error(`Token exchange failed: ${err}`);
+        }
+        const tokens = await tokenRes.json();
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Logged in!</h2><p>You can close this window and return to the terminal.</p></body></html>"
+        );
+        clearTimeout(timeout);
+        server.close();
+        resolve(tokens);
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Login failed.</h2></body></html>"
+        );
+        clearTimeout(timeout);
+        server.close();
+        reject(err);
+      }
+    });
+    server.listen(port, () => {
+      console.log("Opening browser to authorize...");
+      open(authUrl.toString());
+      console.log("Waiting for authorization...");
+    });
+  });
+  let email = "unknown";
+  try {
+    const payload = JSON.parse(
+      Buffer.from(result.access_token.split(".")[1], "base64").toString()
+    );
+    email = payload.email || "unknown";
+  } catch {
+  }
+  const expiresAt = Math.floor(Date.now() / 1e3) + result.expires_in;
+  saveAuth({
+    access_token: result.access_token,
+    refresh_token: result.refresh_token,
+    expires_at: expiresAt
+  });
+  let orgId;
+  try {
+    const orgsRes = await api.get("/v1/orgs");
+    if (orgsRes.ok) {
+      const { orgs } = await orgsRes.json();
+      if (orgs.length === 1) {
+        orgId = orgs[0].id;
+        console.log(`Organization: ${orgs[0].name}`);
+      } else if (orgs.length > 1) {
+        console.log("\nSelect an organization:\n");
+        orgs.forEach((org, i) => {
+          console.log(`  ${i + 1}) ${org.name} (${org.role})`);
+        });
+        console.log();
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const choice = await new Promise((resolve) => {
+          rl.question("Enter number: ", (answer) => {
+            rl.close();
+            resolve(answer.trim());
+          });
+        });
+        const index = parseInt(choice, 10) - 1;
+        if (index >= 0 && index < orgs.length) {
+          orgId = orgs[index].id;
+          console.log(`Selected: ${orgs[index].name}`);
+        } else {
+          orgId = orgs[0].id;
+          console.log(`Defaulting to: ${orgs[0].name}`);
+        }
+      }
+    }
+  } catch {
+  }
+  saveAuth({
+    access_token: result.access_token,
+    refresh_token: result.refresh_token,
+    expires_at: expiresAt,
+    org_id: orgId
+  });
+  console.log(`Logged in as ${email}`);
+}
+// src/commands/deploy.ts
+import path from "path";
+async function deployCommand(dir, options) {
+  let appId;
+  let slug;
+  let appToken;
+  if (options?.from) {
+    const repo = options.from.replace(/^github:/, "");
+    console.log(`Deploying from ${repo}...`);
+    const res = await api.post("/v1/apps/deploy", { repo, branch: "main" });
+    if (!res.ok) {
+      const err = await res.json();
+      console.error(`Deploy failed: ${err.error || res.statusText}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    appId = data.app_id;
+    slug = data.slug;
+    appToken = data.app_token;
+  } else {
+    const resolvedDir = dir ? path.resolve(dir) : process.cwd();
+    const manifest = readManifest(resolvedDir);
+    const name = options?.name || manifest?.name || path.basename(resolvedDir);
+    const framework = manifest?.app?.framework || "vite-preact";
+    console.log(`Deploying ${name}...`);
+    const archive = createArchive(resolvedDir);
+    const formData = new FormData();
+    formData.append("source", new Blob([archive]), "source.tar.gz");
+    formData.append("name", name);
+    formData.append("framework", framework);
+    const res = await api.postForm("/v1/apps/deploy", formData);
+    if (!res.ok) {
+      const err = await res.json();
+      console.error(`Deploy failed: ${err.error || res.statusText}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    appId = data.app_id;
+    slug = data.slug;
+    appToken = data.app_token;
+    saveProject(resolvedDir, {
+      app_id: appId,
+      slug,
+      app_token: appToken
+    });
+  }
+  const result = await pollUntilReady(appId);
+  if (result.status === "error") {
+    console.error(`
+  Deploy failed: ${result.error || "Unknown error"}
+`);
+    process.exit(1);
+  }
+  const url = `https://${slug}.apps.clawnify.com`;
+  console.log(`
+  \u2713 Deployed!  ${url}
+`);
+  console.log(`  Open:  clawnify open ${slug}
+`);
+}
+// src/commands/ls.ts
+async function lsCommand() {
+  const res = await api.get("/v1/apps");
+  if (!res.ok) {
+    console.error("Failed to list apps.");
+    process.exit(1);
+  }
+  const apps = await res.json();
+  if (apps.length === 0) {
+    console.log("No apps deployed yet.");
+    return;
+  }
+  const nameWidth = Math.max(4, ...apps.map((a) => a.name.length));
+  const slugWidth = Math.max(4, ...apps.map((a) => a.slug.length));
+  console.log(
+    `${"Name".padEnd(nameWidth)}  ${"Slug".padEnd(slugWidth)}  ${"Status".padEnd(8)}  URL`
+  );
+  console.log(
+    `${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(slugWidth)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(30)}`
+  );
+  for (const app of apps) {
+    const url = `https://${app.slug}.apps.clawnify.com`;
+    console.log(
+      `${app.name.padEnd(nameWidth)}  ${app.slug.padEnd(slugWidth)}  ${app.status.padEnd(8)}  ${url}`
+    );
+  }
+}
+// src/commands/logs.ts
+async function logsCommand(appId) {
+  const res = await api.get(`/v1/apps/${appId}/logs`);
+  if (!res.ok) {
+    console.error("Failed to fetch logs.");
+    process.exit(1);
+  }
+  const data = await res.json();
+  console.log(`Status: ${data.status}`);
+  if (data.status_message) {
+    console.log(`Message: ${data.status_message}`);
+  }
+  if (data.logs) {
+    console.log("\n--- Build Logs ---\n");
+    console.log(data.logs);
+  }
+}
+// src/commands/rm.ts
+import readline2 from "readline";
+async function rmCommand(appId) {
+  const res = await api.get(`/v1/apps/${appId}`);
+  if (!res.ok) {
+    console.error("App not found.");
+    process.exit(1);
+  }
+  const app = await res.json();
+  const confirmed = await new Promise((resolve) => {
+    const rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`Delete ${app.name}? (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+  if (!confirmed) {
+    console.log("Cancelled.");
+    return;
+  }
+  const delRes = await api.del(`/v1/apps/${appId}`);
+  if (!delRes.ok) {
+    console.error("Failed to delete app.");
+    process.exit(1);
+  }
+  console.log(`Deleted ${app.name}`);
+}
+// src/commands/open.ts
+import open2 from "open";
+async function openCommand(slug) {
+  let appToken;
+  const project = readProject();
+  if (project?.slug === slug && project.app_token) {
+    appToken = project.app_token;
+  }
+  if (!appToken) {
+    const res = await api.get("/v1/apps");
+    if (res.ok) {
+      const apps = await res.json();
+      const app = apps.find((a) => a.slug === slug);
+      appToken = app?.app_token;
+    }
+  }
+  let url = `https://${slug}.apps.clawnify.com`;
+  if (appToken) {
+    url += `?token=${appToken}`;
+  }
+  await open2(url);
+  console.log("Opened in browser");
+}
+// src/commands/whoami.ts
+async function whoamiCommand() {
+  const auth = loadAuth();
+  if (!auth) {
+    console.log("Not logged in");
+    return;
+  }
+  const email = getEmailFromToken(auth.access_token) ?? "unknown";
+  console.log(`Email:  ${email}`);
+  if (auth.org_id) {
+    console.log(`Org:    ${auth.org_id}`);
+  }
+}
+// src/commands/init.ts
+import fs from "fs";
+import path2 from "path";
+import readline3 from "readline";
+function ask(question) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+}
+async function initCommand(dir) {
+  const name = await ask("App name: ") || "my-app";
+  const slug = slugify(name);
+  const targetDir = dir ? path2.resolve(dir) : path2.resolve(slug);
+  console.log();
+  console.log("  Templates:");
+  console.log("  1) blank \u2014 Empty app with a single API route and page");
+  console.log("  2) crud  \u2014 CRUD app with database, list, and form");
+  console.log();
+  const templateChoice = await ask("Template [1]: ") || "1";
+  const template = templateChoice === "2" ? "crud" : "blank";
+  if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+    console.error(`Directory ${targetDir} is not empty.`);
+    process.exit(1);
+  }
+  fs.mkdirSync(path2.join(targetDir, "src/server"), { recursive: true });
+  fs.mkdirSync(path2.join(targetDir, "src/client"), { recursive: true });
+  write(targetDir, "clawnify.json", JSON.stringify({
+    $schema: "https://app.clawnify.com/schema/v1/clawnify.json",
+    version: 1,
+    name,
+    description: "",
+    app: { framework: "preact+hono", database: true, storage: false }
+  }, null, 2));
+  write(targetDir, "package.json", JSON.stringify({
+    name: slug,
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "wrangler dev",
+      build: "vite build"
+    },
+    dependencies: {
+      hono: "^4.0.0",
+      preact: "^10.0.0"
+    },
+    devDependencies: {
+      "@preact/preset-vite": "^2.0.0",
+      "vite": "^6.0.0",
+      "wrangler": "^4.0.0"
+    },
+    pnpm: { onlyBuiltDependencies: ["esbuild"] }
+  }, null, 2));
+  write(targetDir, "tsconfig.json", JSON.stringify({
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      strict: true,
+      lib: ["ESNext", "DOM", "DOM.Iterable"],
+      jsx: "react-jsx",
+      jsxImportSource: "preact",
+      noEmit: true,
+      skipLibCheck: true,
+      resolveJsonModule: true,
+      isolatedModules: true
+    },
+    include: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2));
+  write(targetDir, "vite.config.ts", `import { defineConfig } from "vite";
+import preact from "@preact/preset-vite";
+export default defineConfig({
+  plugins: [preact()],
+  build: {
+    outDir: "dist",
+    emptyOutDir: true,
+  },
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://localhost:8787",
+        changeOrigin: true,
+      },
+    },
+  },
+});
+`);
+  write(targetDir, "wrangler.toml", `name = "${slug}"
+main = "src/server/index.ts"
+compatibility_date = "2025-04-01"
+compatibility_flags = ["nodejs_compat"]
+[[d1_databases]]
+binding = "DB"
+database_name = "${slug}-db"
+database_id = "local"
+[assets]
+directory = "./dist"
+binding = "ASSETS"
+not_found_handling = "single-page-application"
+`);
+  write(targetDir, "index.html", `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${name}</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/src/client/main.tsx"></script>
+</body>
+</html>
+`);
+  write(targetDir, ".gitignore", `node_modules
+dist
+.wrangler
+.clawnify
+`);
+  write(targetDir, "src/server/db.ts", `let _db: D1Database;
+export function initDB(db: D1Database) {
+  _db = db;
+}
+export async function query<T = Record<string, unknown>>(
+  sql: string,
+  params: unknown[] = [],
+): Promise<T[]> {
+  const stmt = _db.prepare(sql).bind(...params);
+  const { results } = await stmt.all<T>();
+  return results ?? [];
+}
+export async function get<T = Record<string, unknown>>(
+  sql: string,
+  params: unknown[] = [],
+): Promise<T | undefined> {
+  const stmt = _db.prepare(sql).bind(...params);
+  const row = await stmt.first<T>();
+  return row ?? undefined;
+}
+export async function run(
+  sql: string,
+  params: unknown[] = [],
+): Promise<{ changes: number; lastInsertRowid: number }> {
+  const stmt = _db.prepare(sql).bind(...params);
+  const result = await stmt.run();
+  return {
+    changes: result.meta?.changes ?? 0,
+    lastInsertRowid: Number(result.meta?.last_row_id ?? 0),
+  };
+}
+`);
+  write(targetDir, "src/server/index.ts", `import { Hono } from "hono";
+import { initDB } from "./db";
+import api from "./routes";
+type Env = { Bindings: { DB: D1Database } };
+const app = new Hono<Env>();
+app.use("*", async (c, next) => {
+  initDB(c.env.DB);
+  await next();
+});
+app.route("/", api);
+export default app;
+`);
+  write(targetDir, "src/client/main.tsx", `import { render } from "preact";
+import { App } from "./app";
+render(<App />, document.getElementById("app")!);
+`);
+  if (template === "crud") {
+    writeCrudTemplate(targetDir, name);
+  } else {
+    writeBlankTemplate(targetDir, name);
+  }
+  console.log();
+  console.log(`  Created ${name} in ${path2.relative(process.cwd(), targetDir)}/`);
+  console.log();
+  console.log("  Get started:");
+  console.log(`    cd ${path2.relative(process.cwd(), targetDir)}`);
+  console.log("    pnpm install");
+  console.log("    pnpm dev          # local dev at http://localhost:8787");
+  console.log("    clawnify deploy   # deploy to production");
+  console.log();
+}
+function writeBlankTemplate(dir, name) {
+  write(dir, "src/server/schema.sql", `CREATE TABLE IF NOT EXISTS items (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`);
+  write(dir, "src/server/routes.ts", `import { Hono } from "hono";
+import { query } from "./db";
+const api = new Hono();
+api.get("/api/items", async (c) => {
+  const items = await query("SELECT * FROM items ORDER BY created_at DESC");
+  return c.json(items);
+});
+export default api;
+`);
+  write(dir, "src/client/app.tsx", `import { useState, useEffect } from "preact/hooks";
+export function App() {
+  const [items, setItems] = useState<any[]>([]);
+  useEffect(() => {
+    fetch("/api/items").then((r) => r.json()).then(setItems);
+  }, []);
+  return (
+    <div style={{ maxWidth: 480, margin: "40px auto", fontFamily: "system-ui" }}>
+      <h1>${name}</h1>
+      <ul>
+        {items.map((item: any) => (
+          <li key={item.id}>{item.name}</li>
+        ))}
+      </ul>
+      {items.length === 0 && <p style={{ color: "#999" }}>No items yet.</p>}
+    </div>
+  );
+}
+`);
+}
+function writeCrudTemplate(dir, name) {
+  write(dir, "src/server/schema.sql", `CREATE TABLE IF NOT EXISTS items (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`);
+  write(dir, "src/server/routes.ts", `import { Hono } from "hono";
+import { query, run } from "./db";
+const api = new Hono();
+api.get("/api/items", async (c) => {
+  const items = await query("SELECT * FROM items ORDER BY created_at DESC");
+  return c.json(items);
+});
+api.post("/api/items", async (c) => {
+  const { title } = await c.req.json<{ title: string }>();
+  if (!title?.trim()) return c.json({ error: "Title required" }, 400);
+  const result = await run("INSERT INTO items (title) VALUES (?)", [title.trim()]);
+  return c.json({ id: result.lastInsertRowid, title: title.trim(), status: "active" }, 201);
+});
+api.patch("/api/items/:id", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json<{ title?: string; status?: string }>();
+  const sets: string[] = [];
+  const params: unknown[] = [];
+  if (body.title !== undefined) { sets.push("title = ?"); params.push(body.title); }
+  if (body.status !== undefined) { sets.push("status = ?"); params.push(body.status); }
+  if (sets.length === 0) return c.json({ error: "Nothing to update" }, 400);
+  params.push(id);
+  await run(\`UPDATE items SET \${sets.join(", ")} WHERE id = ?\`, params);
+  return c.json({ ok: true });
+});
+api.delete("/api/items/:id", async (c) => {
+  const id = c.req.param("id");
+  await run("DELETE FROM items WHERE id = ?", [id]);
+  return c.json({ ok: true });
+});
+export default api;
+`);
+  write(dir, "src/client/app.tsx", `import { useState, useEffect } from "preact/hooks";
+interface Item {
+  id: number;
+  title: string;
+  status: string;
+  created_at: string;
+}
+export function App() {
+  const [items, setItems] = useState<Item[]>([]);
+  const [title, setTitle] = useState("");
+  async function load() {
+    const res = await fetch("/api/items");
+    setItems(await res.json());
+  }
+  useEffect(() => { load(); }, []);
+  async function addItem(e: Event) {
+    e.preventDefault();
+    if (!title.trim()) return;
+    await fetch("/api/items", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ title }),
+    });
+    setTitle("");
+    load();
+  }
+  async function toggleStatus(item: Item) {
+    const next = item.status === "active" ? "done" : "active";
+    await fetch(\`/api/items/\${item.id}\`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ status: next }),
+    });
+    load();
+  }
+  async function deleteItem(id: number) {
+    await fetch(\`/api/items/\${id}\`, { method: "DELETE" });
+    load();
+  }
+  return (
+    <div style={{ maxWidth: 480, margin: "40px auto", fontFamily: "system-ui" }}>
+      <h1>${name}</h1>
+      <form onSubmit={addItem} style={{ display: "flex", gap: 8, marginBottom: 16 }}>
+        <input
+          value={title}
+          onInput={(e) => setTitle((e.target as HTMLInputElement).value)}
+          placeholder="Add an item..."
+          style={{ flex: 1, padding: "8px 12px", borderRadius: 6, border: "1px solid #ddd" }}
+        />
+        <button type="submit" style={{ padding: "8px 16px", borderRadius: 6, background: "#111", color: "#fff", border: "none", cursor: "pointer" }}>
+          Add
+        </button>
+      </form>
+      <ul style={{ listStyle: "none", padding: 0 }}>
+        {items.map((item) => (
+          <li key={item.id} style={{ display: "flex", alignItems: "center", gap: 8, padding: "8px 0", borderBottom: "1px solid #eee" }}>
+            <input type="checkbox" checked={item.status === "done"} onChange={() => toggleStatus(item)} />
+            <span style={{ flex: 1, textDecoration: item.status === "done" ? "line-through" : "none", color: item.status === "done" ? "#999" : "#111" }}>
+              {item.title}
+            </span>
+            <button onClick={() => deleteItem(item.id)} style={{ background: "none", border: "none", color: "#999", cursor: "pointer" }}>
+              \xD7
+            </button>
+          </li>
+        ))}
+      </ul>
+      {items.length === 0 && <p style={{ color: "#999" }}>No items yet. Add one above.</p>}
+    </div>
+  );
+}
+`);
+}
+function write(dir, file, content) {
+  const fullPath = path2.join(dir, file);
+  fs.mkdirSync(path2.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content);
+}
+// src/cli.ts
+function runCli() {
+  const program = new Command();
+  program.name("clawnify").description("Deploy apps to Clawnify").version("0.1.0");
+  program.command("init [dir]").description("Scaffold a new Clawnify app").action(initCommand);
+  program.command("login").description("Authenticate with Clawnify").action(loginCommand);
+  program.command("deploy [dir]").description("Deploy an app to Clawnify").option("--from <repo>", "Deploy from a GitHub repo (owner/repo)").option("--name <name>", "Override app name").action(deployCommand);
+  program.command("ls").description("List deployed apps").action(lsCommand);
+  program.command("logs <app-id>").description("Show build logs for an app").action(logsCommand);
+  program.command("rm <app-id>").description("Delete an app").action(rmCommand);
+  program.command("open <slug>").description("Open an app in the browser").action(openCommand);
+  program.command("whoami").description("Show current user info").action(whoamiCommand);
+  program.parse();
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli-MDRNA6W2.js.map