robodev 0.39.0 → 0.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robodev",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "description": "CLI for Robodev Starbase — create, auth, link, deploy, and run a project locally with robodev dev",
   "type": "module",
   "license": "MIT",
@@ -26,8 +26,8 @@
     "embedded-postgres": "17.10.0-beta.17",
     "fastify": "^5.12.1",
     "tsx": "^4.20.5",
-    "@robodev-ai/sdk": "0.13.0",
-    "@robodev-ai/runtime": "0.5.1"
+    "@robodev-ai/runtime": "0.5.1",
+    "@robodev-ai/sdk": "0.13.0"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/src/emit-starter.test.ts

@@ -114,6 +114,46 @@ test("collectFiles for marketplace starter is Tiny APIs without apps/fe", async
   assert.ok(files.length < 200);
 });
 
+test("emitStarter empty includes hosted Welcome files", async () => {
+  const dest = await mkdtemp(join(tmpdir(), "rd-emit-"));
+  try {
+    await emitStarter(join(cliRoot(), "..", "starters", "empty"), dest, {
+      name: "Blank",
+      packageName: "blank-app",
+      title: "Empty",
+      versions,
+    });
+    const index = await readFile(join(dest, "index.html"), "utf8");
+    assert.match(index, /<title>Blank<\/title>/);
+    assert.match(index, /src\/main\.tsx/);
+    const main = await readFile(join(dest, "src/main.tsx"), "utf8");
+    assert.match(main, /createRoot/);
+    const pkg = JSON.parse(await readFile(join(dest, "package.json"), "utf8")) as {
+      name: string;
+      scripts?: Record<string, string>;
+      dependencies?: Record<string, string>;
+    };
+    assert.equal(pkg.name, "blank-app");
+    assert.equal(pkg.scripts?.dev, "robodev dev");
+    assert.equal(pkg.scripts?.["dev:fe"], "vite");
+    assert.equal(pkg.dependencies?.["@robodev-ai/client"], "^0.12.0");
+  } finally {
+    await rm(dest, { recursive: true, force: true });
+  }
+});
+
+test("collectFiles for empty starter includes hosted Welcome source", async () => {
+  const files = await collectFiles(join(cliRoot(), "..", "starters", "empty"));
+  const paths = new Set(files.map((file) => file.path));
+  assert.ok(paths.has("robodev/database.ts"));
+  assert.ok(paths.has("robodev/api/health.ts"));
+  assert.ok(paths.has("index.html"));
+  assert.ok(paths.has("src/main.tsx"));
+  assert.ok(!paths.has("robodev/api/planets.ts"));
+  assert.ok([...paths].every((path) => !path.startsWith("apps/")));
+  assert.ok(files.length < 200);
+});
+
 test("collectFiles for space starter is Tiny APIs without apps/fe", async () => {
   const files = await collectFiles(join(cliRoot(), "..", "starters", "space"));
   const paths = new Set(files.map((file) => file.path));

package/src/frontend-source.test.ts

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { collectFrontendSource, shouldCollectFrontendSource } from "./frontend-source.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+test("deploy posts frontendSource beside files", () => {
+  const source = readFileSync(join(here, "index.ts"), "utf8");
+  assert.match(source, /collectFrontendSource/);
+  assert.match(source, /collectDeployPayload/);
+  assert.match(source, /frontendSource\.length > 0 \? \{ frontendSource \}/);
+});
+
+test("shouldCollectFrontendSource when .robodev has frontend or apps/fe exists", () => {
+  assert.equal(
+    shouldCollectFrontendSource({ hasFrontendConfig: true, hasAppsFePackageJson: false }),
+    true,
+  );
+  assert.equal(
+    shouldCollectFrontendSource({ hasFrontendConfig: false, hasAppsFePackageJson: true }),
+    true,
+  );
+  assert.equal(
+    shouldCollectFrontendSource({ hasFrontendConfig: false, hasAppsFePackageJson: false }),
+    false,
+  );
+});
+
+test("collectFrontendSource walks apps/fe and skips dist, node_modules, and .env", async () => {
+  const root = await mkdtemp(join(tmpdir(), "rd-fe-src-"));
+  try {
+    await mkdir(join(root, "apps/fe/src"), { recursive: true });
+    await mkdir(join(root, "apps/fe/node_modules/left"), { recursive: true });
+    await mkdir(join(root, "apps/fe/dist"), { recursive: true });
+    await writeFile(join(root, "apps/fe/package.json"), '{"name":"fe"}');
+    await writeFile(join(root, "apps/fe/index.html"), "<html></html>");
+    await writeFile(join(root, "apps/fe/src/main.tsx"), "export {}");
+    await writeFile(join(root, "apps/fe/.env"), "SECRET=1");
+    await writeFile(join(root, "apps/fe/node_modules/left/index.js"), "nope");
+    await writeFile(join(root, "apps/fe/dist/index.html"), "<html>built</html>");
+    await writeFile(join(root, "database.ts"), "export default {}");
+
+    const files = await collectFrontendSource(root, "apps/fe");
+    const paths = new Set(files.map((file) => file.path));
+    assert.ok(paths.has("apps/fe/package.json"));
+    assert.ok(paths.has("apps/fe/index.html"));
+    assert.ok(paths.has("apps/fe/src/main.tsx"));
+    assert.ok(!paths.has("apps/fe/.env"));
+    assert.ok(!paths.has("apps/fe/node_modules/left/index.js"));
+    assert.ok(!paths.has("apps/fe/dist/index.html"));
+    assert.ok(!paths.has("database.ts"));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("collectFrontendSource walks root FE without backend files", async () => {
+  const root = await mkdtemp(join(tmpdir(), "rd-fe-root-"));
+  try {
+    await mkdir(join(root, "src"), { recursive: true });
+    await mkdir(join(root, "api"), { recursive: true });
+    await writeFile(join(root, "database.ts"), "export default {}");
+    await writeFile(join(root, "index.html"), "<html></html>");
+    await writeFile(join(root, "src/main.tsx"), "export {}");
+    await writeFile(join(root, "package.json"), "{}");
+    await writeFile(join(root, "vite.config.ts"), "export default {}");
+    await writeFile(join(root, "api/health.ts"), "export {}");
+
+    const files = await collectFrontendSource(root, ".");
+    const paths = new Set(files.map((file) => file.path));
+    assert.ok(paths.has("index.html"));
+    assert.ok(paths.has("src/main.tsx"));
+    assert.ok(paths.has("package.json"));
+    assert.ok(paths.has("vite.config.ts"));
+    assert.ok(!paths.has("database.ts"));
+    assert.ok(!paths.has("api/health.ts"));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/frontend-source.ts

@@ -0,0 +1,83 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { isWorkspaceFrontendSourcePath } from "@robodev-ai/runtime";
+import {
+  MAX_FILE_BYTES,
+  MAX_FILE_COUNT,
+  MAX_PATH_DEPTH,
+  MAX_PATH_LENGTH,
+  MAX_TREE_BYTES,
+  type CollectedFile,
+} from "./collect-files.js";
+import { sanitizeProjectRelative } from "./frontend-build.js";
+
+const SKIP_DIRS = new Set(["node_modules", "dist", ".git", ".robodev"]);
+
+function normalize(path: string): string {
+  return path.replaceAll("\\", "/");
+}
+
+function formatMaxBytes(bytes: number): string {
+  return `${Math.round(bytes / (1024 * 1024))}MB`;
+}
+
+export async function collectFrontendSource(
+  projectRoot: string,
+  frontendRoot: string,
+): Promise<CollectedFile[]> {
+  const rootAbs = sanitizeProjectRelative(projectRoot, frontendRoot, "root");
+  try {
+    if (!(await stat(rootAbs)).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+
+  const files: CollectedFile[] = [];
+  let totalBytes = 0;
+
+  async function walk(dir: string): Promise<void> {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const path = normalize(relative(projectRoot, abs));
+      if (!isWorkspaceFrontendSourcePath(path)) continue;
+      if (path.length > MAX_PATH_LENGTH || path.split("/").length > MAX_PATH_DEPTH) {
+        throw new Error(`Invalid file path: ${path}`);
+      }
+      const content = await readFile(abs, "utf8");
+      const bytes = Buffer.byteLength(content, "utf8");
+      if (bytes > MAX_FILE_BYTES) {
+        throw new Error(`File must be under ${formatMaxBytes(MAX_FILE_BYTES)}: ${path}`);
+      }
+      totalBytes += bytes;
+      if (totalBytes > MAX_TREE_BYTES) {
+        throw new Error(`Frontend source tree must be under ${formatMaxBytes(MAX_TREE_BYTES)}`);
+      }
+      files.push({ path, content });
+      if (files.length > MAX_FILE_COUNT) {
+        throw new Error(`Frontend source may include at most ${MAX_FILE_COUNT} files`);
+      }
+    }
+  }
+
+  await walk(rootAbs);
+  return files;
+}
+
+export function shouldCollectFrontendSource(input: {
+  hasFrontendConfig: boolean;
+  hasAppsFePackageJson: boolean;
+}): boolean {
+  return input.hasFrontendConfig || input.hasAppsFePackageJson;
+}

package/src/index.ts

@@ -28,6 +28,7 @@ import {
   commandAvailable,
   frontendOutIndexExists,
 } from "./frontend-build.js";
+import { collectFrontendSource, shouldCollectFrontendSource } from "./frontend-source.js";
 import {
   emitStarter,
   loadCatalog,
@@ -52,7 +53,7 @@ Commands:
   logout               Remove stored credentials
   whoami               Show the signed-in user
   projects             List your projects
-  create [path] [--starter <id>] [--empty] [--org <id>]  Create a project, scaffold a starter, and deploy
+  create [path] [--template <id>] [--starter <id>] [--empty] [--org <id>]  Create a project, scaffold a starter, and deploy
   link [projectId]     Write robodev/.robodev in the current folder
   deploy [--force] [--name <name>] [--org <id>]  Deploy schema, APIs, jobs, and frontend (creates and links if unlinked)
   dev [options]        Run this project's APIs locally on an embedded Postgres, no Starbase needed
@@ -227,22 +228,32 @@ type DeployOptions = {
   skipFrontendBuild?: boolean;
 };
 
-async function collectDeployFiles(
+async function collectDeployPayload(
   root: string,
   link: ProjectLink,
   options: DeployOptions,
-): Promise<CollectedFile[]> {
+): Promise<{ files: CollectedFile[]; frontendSource: CollectedFile[] }> {
   const collected = await collectFiles(root);
+  const hasAppsFe = await hasAppsFePackageJson(root);
+  const frontendSource = shouldCollectFrontendSource({
+    hasFrontendConfig: isFrontendConfig(link.frontend),
+    hasAppsFePackageJson: hasAppsFe,
+  })
+    ? await collectFrontendSource(
+        root,
+        isFrontendConfig(link.frontend) ? link.frontend.root : "apps/fe",
+      )
+    : [];
   if (options.frontendFiles) {
-    return mergeCollectedFiles(collected, options.frontendFiles);
+    return { files: mergeCollectedFiles(collected, options.frontendFiles), frontendSource };
   }
   if (options.skipFrontendBuild || !isFrontendConfig(link.frontend)) {
-    return collected;
+    return { files: collected, frontendSource };
   }
   const frontendFiles = await buildAndCollectFrontend(root, link.frontend, {
     install: "if-needed",
   });
-  return mergeCollectedFiles(collected, frontendFiles);
+  return { files: mergeCollectedFiles(collected, frontendFiles), frontendSource };
 }
 
 /** Uploads schema, APIs, and frontend. Destructive schema changes need confirmation or `--force`. */
@@ -274,7 +285,7 @@ async function runDeploy(
       promptName: (defaultName) => prompt(`Project name [${defaultName}]: `),
     },
   );
-  const files = await collectDeployFiles(root, link, options);
+  const { files, frontendSource } = await collectDeployPayload(root, link, options);
   let force = forceFlag;
 
   for (;;) {
@@ -290,7 +301,11 @@ async function runDeploy(
         plan: { operations: { type: string; table: string; column?: string; sql: string }[] };
       }>(`/v1/projects/${link.projectId}/deploy`, {
         method: "POST",
-        body: JSON.stringify({ force, files }),
+        body: JSON.stringify({
+          force,
+          files,
+          ...(frontendSource.length > 0 ? { frontendSource } : {}),
+        }),
       });
       await waitUntilLive(result.apiUrl);
       console.log(`App      ${result.appUrl ?? result.apiUrl}`);
@@ -397,40 +412,47 @@ async function resolveOrganization(flagId: string | undefined): Promise<string |
   return found.id;
 }
 
-async function resolveStarter(flagId: string | undefined): Promise<Starter> {
+async function resolveStarter(parsed: {
+  starterId?: string;
+  promptTemplate?: boolean;
+}): Promise<Starter> {
   const starters = await loadCatalog();
-  if (flagId !== undefined) {
-    const found = starters.find((starter) => starter.id === flagId);
+  if (parsed.starterId !== undefined) {
+    const found = starters.find((starter) => starter.id === parsed.starterId);
     if (!found) {
-      throw new Error(`Unknown starter "${flagId}". ${validIdsMessage(starters)}`);
+      throw new Error(`Unknown starter "${parsed.starterId}". ${validIdsMessage(starters)}`);
     }
     return found;
   }
-  if (stdin.isTTY) {
-    console.log("Starters:");
-    starters.forEach((starter, i) => {
-      console.log(`  ${i + 1}. ${starter.title} (${starter.id})`);
-      console.log(`     ${starter.description}`);
-    });
-    const answer = (await prompt("Starter number or id: ")).trim();
-    if (!answer) {
-      throw new Error(`Unknown starter "". ${validIdsMessage(starters)}`);
-    }
-    const asIndex = Number(answer);
-    if (Number.isInteger(asIndex) && asIndex >= 1 && asIndex <= starters.length) {
-      return starters[asIndex - 1];
-    }
-    const found = starters.find((starter) => starter.id === answer);
-    if (!found) {
-      throw new Error(`Unknown starter "${answer}". ${validIdsMessage(starters)}`);
+  if (parsed.promptTemplate) {
+    if (stdin.isTTY) {
+      console.log("Starters:");
+      starters.forEach((starter, i) => {
+        console.log(`  ${i + 1}. ${starter.title} (${starter.id})`);
+        console.log(`     ${starter.description}`);
+      });
+      const answer = (await prompt("Starter number or id: ")).trim();
+      if (!answer) {
+        throw new Error(`Unknown starter "". ${validIdsMessage(starters)}`);
+      }
+      const asIndex = Number(answer);
+      if (Number.isInteger(asIndex) && asIndex >= 1 && asIndex <= starters.length) {
+        return starters[asIndex - 1];
+      }
+      const found = starters.find((starter) => starter.id === answer);
+      if (!found) {
+        throw new Error(`Unknown starter "${answer}". ${validIdsMessage(starters)}`);
+      }
+      return found;
     }
-    return found;
+    console.log("robodev create --template requires a starter id when stdin is not a TTY.");
+    usage();
   }
-  const space = starters.find((starter) => starter.id === "space");
-  if (!space) {
-    throw new Error(`Unknown starter "space". ${validIdsMessage(starters)}`);
+  const empty = starters.find((starter) => starter.id === "empty");
+  if (!empty) {
+    throw new Error(`Unknown starter "empty". ${validIdsMessage(starters)}`);
   }
-  return space;
+  return empty;
 }
 
 function projectNameFromPath(root: string): string {
@@ -528,7 +550,7 @@ function printFeNextSteps(displayPath: string, hosted: boolean): void {
 /** Creates a Starbase project, copies the chosen starter, links, deploys, and installs deps. */
 async function runCreate(args: string[]): Promise<void> {
   const parsed = parseCreateArgs(args);
-  const starter = await resolveStarter(parsed.starterId);
+  const starter = await resolveStarter(parsed);
   console.log(`Using starter ${starter.title} (${starter.id})`);
 
   const root = resolve(process.cwd(), parsed.path ?? ".");
@@ -623,7 +645,10 @@ async function runCreate(args: string[]): Promise<void> {
     if (displayPath !== ".") {
       console.log(`  cd ${displayPath}`);
     }
-    console.log("  npm run dev");
+    console.log("  The project App URL serves the hosted Welcome page.");
+    console.log("  Edit index.html and src/, then robodev deploy (or Code + Save).");
+    console.log("  robodev dev          # local APIs");
+    console.log("  npm run dev:fe       # optional local Vite");
   }
   if (liveUrl) {
     printLiveUrl(liveUrl);

package/src/parse-create-args.test.ts

@@ -2,17 +2,86 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 import { parseCreateArgs } from "./parse-create-args.js";
 
-test("parseCreateArgs accepts --org with starter flags", () => {
+test("parseCreateArgs defaults to empty without a template flag", () => {
+  assert.deepEqual(parseCreateArgs([]), {
+    path: undefined,
+    starterId: "empty",
+    orgId: undefined,
+  });
+  assert.deepEqual(parseCreateArgs(["my-app"]), {
+    path: "my-app",
+    starterId: "empty",
+    orgId: undefined,
+  });
+});
+
+test("parseCreateArgs accepts --template and --starter with an id", () => {
+  assert.deepEqual(parseCreateArgs(["app", "--template", "space", "--org", "org_1"]), {
+    path: "app",
+    starterId: "space",
+    orgId: "org_1",
+  });
+  assert.deepEqual(parseCreateArgs(["--template=auth-chat"]), {
+    path: undefined,
+    starterId: "auth-chat",
+    orgId: undefined,
+  });
   assert.deepEqual(parseCreateArgs(["app", "--starter", "space", "--org", "org_1"]), {
     path: "app",
     starterId: "space",
     orgId: "org_1",
   });
+  assert.deepEqual(parseCreateArgs(["--starter=backend"]), {
+    path: undefined,
+    starterId: "backend",
+    orgId: undefined,
+  });
+});
+
+test("parseCreateArgs treats bare --template and --starter as a picker request", () => {
+  assert.deepEqual(parseCreateArgs(["--template"]), {
+    path: undefined,
+    starterId: undefined,
+    orgId: undefined,
+    promptTemplate: true,
+  });
+  assert.deepEqual(parseCreateArgs(["--template="]), {
+    path: undefined,
+    starterId: undefined,
+    orgId: undefined,
+    promptTemplate: true,
+  });
+  assert.deepEqual(parseCreateArgs(["my-app", "--template", "--org", "org_1"]), {
+    path: "my-app",
+    starterId: undefined,
+    orgId: "org_1",
+    promptTemplate: true,
+  });
+  assert.deepEqual(parseCreateArgs(["--starter"]), {
+    path: undefined,
+    starterId: undefined,
+    orgId: undefined,
+    promptTemplate: true,
+  });
+  assert.deepEqual(parseCreateArgs(["--starter="]), {
+    path: undefined,
+    starterId: undefined,
+    orgId: undefined,
+    promptTemplate: true,
+  });
+});
+
+test("parseCreateArgs treats --empty as empty", () => {
   assert.deepEqual(parseCreateArgs(["--empty", "--org=org_2"]), {
     path: undefined,
     starterId: "empty",
     orgId: "org_2",
   });
+  assert.deepEqual(parseCreateArgs(["--template", "empty"]), {
+    path: undefined,
+    starterId: "empty",
+    orgId: undefined,
+  });
 });
 
 test("parseCreateArgs rejects a missing --org value", () => {
@@ -21,13 +90,26 @@ test("parseCreateArgs rejects a missing --org value", () => {
   assert.throws(() => parseCreateArgs(["--org", "--empty"]), /Missing value for --org/);
 });
 
-test("parseCreateArgs rejects unknown flags including --organization", () => {
+test("parseCreateArgs rejects unknown flags including --organization and --empty=", () => {
   assert.throws(() => parseCreateArgs(["--organization", "org_1"]), /Unknown flag --organization/);
+  assert.throws(() => parseCreateArgs(["--empty=empty"]), /Unknown flag --empty=empty/);
 });
 
-test("parseCreateArgs rejects --empty together with --starter", () => {
+test("parseCreateArgs rejects two starter selectors", () => {
   assert.throws(
     () => parseCreateArgs(["--empty", "--starter", "empty"]),
-    /Use either --empty or --starter, not both/,
+    /Use only one of --empty, --template, or --starter\./,
+  );
+  assert.throws(
+    () => parseCreateArgs(["--empty", "--template", "empty"]),
+    /Use only one of --empty, --template, or --starter\./,
+  );
+  assert.throws(
+    () => parseCreateArgs(["--template", "space", "--starter", "space"]),
+    /Use only one of --empty, --template, or --starter\./,
+  );
+  assert.throws(
+    () => parseCreateArgs(["--template", "--empty"]),
+    /Use only one of --empty, --template, or --starter\./,
   );
 });

package/src/parse-create-args.ts

@@ -1,31 +1,64 @@
-export type CreateArgs = { path?: string; starterId?: string; orgId?: string };
+export type CreateArgs = {
+  path?: string;
+  starterId?: string;
+  orgId?: string;
+  promptTemplate?: boolean;
+};
+
+function takeOptionalId(
+  args: string[],
+  i: number,
+): { value?: string; prompt: boolean; consumed: number } {
+  const next = args[i + 1];
+  if (!next || next.startsWith("-")) {
+    return { prompt: true, consumed: 0 };
+  }
+  return { value: next, prompt: false, consumed: 1 };
+}
 
 export function parseCreateArgs(args: string[]): CreateArgs {
   let path: string | undefined;
   let starterId: string | undefined;
   let orgId: string | undefined;
   let empty = false;
+  let sawTemplate = false;
+  let sawStarter = false;
+  let promptTemplate = false;
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--empty") {
       empty = true;
       continue;
     }
+    if (arg === "--template") {
+      sawTemplate = true;
+      const taken = takeOptionalId(args, i);
+      if (taken.prompt) promptTemplate = true;
+      else starterId = taken.value;
+      i += taken.consumed;
+      continue;
+    }
+    if (arg.startsWith("--template=")) {
+      sawTemplate = true;
+      const value = arg.slice("--template=".length);
+      if (!value) promptTemplate = true;
+      else starterId = value;
+      continue;
+    }
     if (arg === "--starter") {
-      const value = args[i + 1];
-      if (!value || value.startsWith("-")) {
-        throw new Error("Missing value for --starter");
-      }
-      starterId = value;
-      i += 1;
+      sawStarter = true;
+      const taken = takeOptionalId(args, i);
+      if (taken.prompt) promptTemplate = true;
+      else starterId = taken.value;
+      i += taken.consumed;
       continue;
     }
     if (arg.startsWith("--starter=")) {
+      sawStarter = true;
       const value = arg.slice("--starter=".length);
-      if (!value) {
-        throw new Error("Missing value for --starter");
-      }
-      starterId = value;
+      if (!value) promptTemplate = true;
+      else starterId = value;
       continue;
     }
     if (arg === "--org") {
@@ -53,11 +86,15 @@ export function parseCreateArgs(args: string[]): CreateArgs {
     }
     path = arg;
   }
-  if (empty && starterId !== undefined) {
-    throw new Error("Use either --empty or --starter, not both.");
+
+  const selectors = Number(empty) + Number(sawTemplate) + Number(sawStarter);
+  if (selectors > 1) {
+    throw new Error("Use only one of --empty, --template, or --starter.");
   }
   if (empty) {
     starterId = "empty";
+  } else if (!sawTemplate && !sawStarter) {
+    starterId = "empty";
   }
-  return { path, starterId, orgId };
+  return { path, starterId, orgId, ...(promptTemplate ? { promptTemplate: true } : {}) };
 }

package/templates/auth-chat/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.39.0",
+    "robodev": "^0.41.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/backend/package.json

@@ -11,7 +11,7 @@
     "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.39.0",
+    "robodev": "^0.41.0",
     "typescript": "^5.9.2"
   }
 }

package/templates/catalog.json

@@ -24,8 +24,7 @@
     {
       "id": "empty",
       "title": "Empty",
-      "description": "Blank database.ts and GET /api/health — no sample schema or UI. For Lovable, Bolt, or v0",
-      "kind": "backend"
+      "description": "Blank database.ts and GET /api/health plus a hosted Welcome page. No sample schema."
     }
   ]
 }

package/templates/empty/README.md

@@ -1,15 +1,17 @@
 # {{NAME}}
 
-Blank `robodev/database.ts` and `GET /api/health` — no sample schema or UI. For Lovable, Bolt, or v0.
+Blank `robodev/database.ts` and `GET /api/health` plus a hosted Welcome page. No sample schema.
 
-Deploy `robodev/database.ts` and `robodev/api/` from a real terminal:
+The project App URL serves the hosted Welcome page. Edit `index.html` and `src/`, then `robodev deploy` (or Code + Save).
 
 ```bash
-npx robodev deploy
+robodev create my-app
+robodev dev          # local APIs
+npm run dev:fe       # optional local Vite
 ```
 
-Build the UI elsewhere against `VITE_API_URL` (written to `.env` by `robodev create` / `robodev link`). Paste that URL into the frontend tool.
+`robodev create` (TTY and non-TTY) uses this starter by default. Pass `--template space` for Space. Lovable, Bolt, or v0 should use `--template backend`.
 
-Do not run `npm run dev` or `npm run build` in this folder. Do not run `robodev` (auth, create, deploy) or `npm run build` inside Lovable, Bolt, or v0 — those tools cannot complete loopback OAuth and must not treat this folder as a Vite app.
+Do not write a `frontend` block in `robodev/.robodev` — that block is for Tiny `apps/fe`. Root `index.html` + `src/` deploy as hosted React.
 
-Frontend how-to: https://robodev.povio.dev/docs/frontend
+Docs: https://robodev.povio.dev/docs

package/templates/empty/index.html

@@ -0,0 +1,12 @@
+<!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="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/empty/package.json

@@ -5,13 +5,19 @@
   "type": "module",
   "scripts": {
     "dev": "robodev dev",
-    "deploy": "robodev deploy"
+    "deploy": "robodev deploy",
+    "dev:fe": "vite",
+    "build": "vite build"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.13.0"
+    "@robodev-ai/sdk": "^0.13.0",
+    "@robodev-ai/client": "^0.5.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "devDependencies": {
-    "robodev": "^0.39.0",
-    "typescript": "^5.9.2"
+    "robodev": "^0.41.0",
+    "typescript": "^5.9.2",
+    "vite": "^6.0.0"
   }
 }

package/templates/empty/src/App.tsx

@@ -0,0 +1,8 @@
+export function App() {
+  return (
+    <main>
+      <h1>Welcome</h1>
+      <p>Your app is ready.</p>
+    </main>
+  );
+}

package/templates/empty/src/app.css

@@ -0,0 +1,10 @@
+:root {
+  color: #111;
+  font-family: system-ui, sans-serif;
+}
+body {
+  margin: 0;
+}
+main {
+  padding: 2rem;
+}

package/templates/empty/src/main.tsx

@@ -0,0 +1,5 @@
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
+import "./app.css";
+
+createRoot(document.getElementById("root")!).render(<App />);

package/templates/empty/tsconfig.json

@@ -3,9 +3,10 @@
     "target": "ES2022",
     "module": "ESNext",
     "moduleResolution": "bundler",
+    "jsx": "react-jsx",
     "strict": true,
     "skipLibCheck": true,
     "noEmit": true
   },
-  "include": ["robodev/**/*.ts"]
+  "include": ["robodev/**/*.ts", "src"]
 }

package/templates/empty/vite.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  esbuild: { jsx: "automatic" },
+});

package/templates/marketplace/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.39.0",
+    "robodev": "^0.41.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/space/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.39.0",
+    "robodev": "^0.41.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }