robodev 0.38.0 → 0.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robodev",
-  "version": "0.38.0",
+  "version": "0.39.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/runtime": "0.5.0",
-    "@robodev-ai/sdk": "0.12.0"
+    "@robodev-ai/sdk": "0.13.0",
+    "@robodev-ai/runtime": "0.5.1"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/src/ensure-deploy-link.test.ts

@@ -0,0 +1,228 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  ensureDeployLink,
+  UNLINKED_NON_TTY_MESSAGE,
+  type EnsureDeployLinkDeps,
+  type EnsureDeployLinkInput,
+} from "./ensure-deploy-link.js";
+import { defaultFrontendConfig, type ProjectLink } from "./config.js";
+
+const linked: ProjectLink = {
+  projectId: "proj_existing",
+  apiUrl: "https://robodev.povio.dev",
+  projectApiUrl: "https://proj_existing.robodev.povio.dev",
+};
+
+function stubDeps(overrides: Partial<EnsureDeployLinkDeps> = {}): EnsureDeployLinkDeps & {
+  calls: {
+    ensureAuth: number;
+    collectFiles: number;
+    resolveOrganization: number;
+    createProject: number;
+    writeLink: number;
+    writeViteApiUrl: number;
+    promptName: number;
+  };
+  createdBodies: { name: string; organizationId?: string }[];
+  writtenLinks: ProjectLink[];
+} {
+  const calls = {
+    ensureAuth: 0,
+    collectFiles: 0,
+    resolveOrganization: 0,
+    createProject: 0,
+    writeLink: 0,
+    writeViteApiUrl: 0,
+    promptName: 0,
+  };
+  const createdBodies: { name: string; organizationId?: string }[] = [];
+  const writtenLinks: ProjectLink[] = [];
+  return {
+    calls,
+    createdBodies,
+    writtenLinks,
+    readLink: async () => null,
+    collectFiles: async () => {
+      calls.collectFiles += 1;
+      return [];
+    },
+    ensureAuth: async () => {
+      calls.ensureAuth += 1;
+    },
+    resolveOrganization: async (flagId) => {
+      calls.resolveOrganization += 1;
+      return flagId;
+    },
+    createProject: async (body) => {
+      calls.createProject += 1;
+      createdBodies.push(body);
+      return { id: "proj_new", name: body.name, apiUrl: "https://proj_new.robodev.povio.dev" };
+    },
+    writeLink: async (link) => {
+      calls.writeLink += 1;
+      writtenLinks.push(link);
+    },
+    writeViteApiUrl: async () => {
+      calls.writeViteApiUrl += 1;
+    },
+    hasAppsFePackageJson: async () => false,
+    starbaseUrl: () => "https://robodev.povio.dev",
+    projectNameFromPath: () => "my-folder",
+    promptName: async () => {
+      calls.promptName += 1;
+      return "";
+    },
+    ...overrides,
+    ...(overrides.collectFiles
+      ? {
+          collectFiles: async (root: string) => {
+            calls.collectFiles += 1;
+            return overrides.collectFiles!(root);
+          },
+        }
+      : {}),
+    ...(overrides.ensureAuth
+      ? {
+          ensureAuth: async () => {
+            calls.ensureAuth += 1;
+            return overrides.ensureAuth!();
+          },
+        }
+      : {}),
+    ...(overrides.resolveOrganization
+      ? {
+          resolveOrganization: async (flagId: string | undefined) => {
+            calls.resolveOrganization += 1;
+            return overrides.resolveOrganization!(flagId);
+          },
+        }
+      : {}),
+    ...(overrides.createProject
+      ? {
+          createProject: async (body: { name: string; organizationId?: string }) => {
+            calls.createProject += 1;
+            createdBodies.push(body);
+            return overrides.createProject!(body);
+          },
+        }
+      : {}),
+    ...(overrides.writeLink
+      ? {
+          writeLink: async (link: ProjectLink, root: string) => {
+            calls.writeLink += 1;
+            writtenLinks.push(link);
+            return overrides.writeLink!(link, root);
+          },
+        }
+      : {}),
+    ...(overrides.writeViteApiUrl
+      ? {
+          writeViteApiUrl: async (url: string, root: string) => {
+            calls.writeViteApiUrl += 1;
+            return overrides.writeViteApiUrl!(url, root);
+          },
+        }
+      : {}),
+    ...(overrides.promptName
+      ? {
+          promptName: async (defaultName: string) => {
+            calls.promptName += 1;
+            return overrides.promptName!(defaultName);
+          },
+        }
+      : {}),
+  };
+}
+
+async function run(input: Partial<EnsureDeployLinkInput>, deps: ReturnType<typeof stubDeps>) {
+  return ensureDeployLink({ root: "/tmp/app", isTty: false, ...input }, deps);
+}
+
+test("ensureDeployLink returns an existing link and does not create again", async () => {
+  const deps = stubDeps({ readLink: async () => linked });
+  const result = await run({ name: "Ignored", orgId: "org_x", isTty: true }, deps);
+  assert.deepEqual(result, linked);
+  assert.equal(deps.calls.ensureAuth, 0);
+  assert.equal(deps.calls.collectFiles, 0);
+  assert.equal(deps.calls.createProject, 0);
+  assert.equal(deps.calls.writeLink, 0);
+  assert.equal(deps.calls.resolveOrganization, 0);
+});
+
+test("ensureDeployLink fails collect before creating a project", async () => {
+  const deps = stubDeps({
+    collectFiles: async () => {
+      throw new Error("database.ts not found (looked in robodev/database.ts and ./database.ts)");
+    },
+  });
+  await assert.rejects(() => run({ name: "Orbit", isTty: false }, deps), /database\.ts not found/);
+  assert.equal(deps.calls.ensureAuth, 1);
+  assert.equal(deps.calls.collectFiles, 1);
+  assert.equal(deps.calls.createProject, 0);
+  assert.equal(deps.calls.writeLink, 0);
+  assert.equal(deps.calls.resolveOrganization, 0);
+});
+
+test("ensureDeployLink non-TTY without --name exits without creating", async () => {
+  const deps = stubDeps();
+  await assert.rejects(() => run({ isTty: false }, deps), new Error(UNLINKED_NON_TTY_MESSAGE));
+  assert.equal(deps.calls.ensureAuth, 1);
+  assert.equal(deps.calls.collectFiles, 1);
+  assert.equal(deps.calls.createProject, 0);
+  assert.equal(deps.calls.writeLink, 0);
+  assert.equal(deps.calls.promptName, 0);
+  assert.equal(deps.calls.resolveOrganization, 0);
+});
+
+test("ensureDeployLink TTY prompts for name and writes the link before returning", async () => {
+  const deps = stubDeps({
+    promptName: async (defaultName) => {
+      assert.equal(defaultName, "my-folder");
+      return "";
+    },
+  });
+  const result = await run({ isTty: true }, deps);
+  assert.equal(deps.calls.promptName, 1);
+  assert.deepEqual(deps.createdBodies, [{ name: "my-folder" }]);
+  assert.equal(deps.calls.writeLink, 1);
+  assert.equal(deps.calls.writeViteApiUrl, 1);
+  assert.equal(deps.calls.createProject, 1);
+  assert.ok(deps.calls.writeLink >= 1);
+  assert.deepEqual(result, deps.writtenLinks[0]);
+  assert.equal(result.projectId, "proj_new");
+  assert.equal(result.frontend, undefined);
+});
+
+test("ensureDeployLink TTY uses a typed name and optional org", async () => {
+  const deps = stubDeps({
+    resolveOrganization: async (flagId) => flagId,
+    promptName: async () => "From prompt",
+  });
+  await run({ isTty: true, orgId: "org_2" }, deps);
+  assert.deepEqual(deps.createdBodies, [{ name: "From prompt", organizationId: "org_2" }]);
+});
+
+test("ensureDeployLink non-TTY with --name creates a name-only project", async () => {
+  const deps = stubDeps({
+    hasAppsFePackageJson: async () => true,
+  });
+  const result = await run({ isTty: false, name: "  Orbit  ", orgId: "org_1" }, deps);
+  assert.equal(deps.calls.promptName, 0);
+  assert.deepEqual(deps.createdBodies, [{ name: "Orbit", organizationId: "org_1" }]);
+  assert.equal("starterId" in deps.createdBodies[0], false);
+  assert.deepEqual(result.frontend, defaultFrontendConfig());
+  assert.equal(deps.calls.writeLink, 1);
+});
+
+test("ensureDeployLink auth failure happens before collect and create", async () => {
+  const deps = stubDeps({
+    ensureAuth: async () => {
+      throw new Error("Not authenticated. Run `robodev auth` first.");
+    },
+  });
+  await assert.rejects(() => run({ name: "Orbit", isTty: false }, deps), /Not authenticated/);
+  assert.equal(deps.calls.ensureAuth, 1);
+  assert.equal(deps.calls.collectFiles, 0);
+  assert.equal(deps.calls.createProject, 0);
+});

package/src/ensure-deploy-link.ts

@@ -0,0 +1,67 @@
+import { defaultFrontendConfig, type ProjectLink } from "./config.js";
+
+export type DeployProject = { id: string; name: string; apiUrl: string };
+
+export const UNLINKED_NON_TTY_MESSAGE =
+  "No robodev/.robodev file. Pass --name / --org or run `robodev link` or `robodev create`.";
+
+export type EnsureDeployLinkInput = {
+  root: string;
+  name?: string;
+  orgId?: string;
+  isTty: boolean;
+};
+
+export type EnsureDeployLinkDeps = {
+  readLink: (root: string) => Promise<ProjectLink | null>;
+  collectFiles: (root: string) => Promise<unknown>;
+  ensureAuth: () => Promise<void>;
+  resolveOrganization: (flagId: string | undefined) => Promise<string | undefined>;
+  createProject: (body: { name: string; organizationId?: string }) => Promise<DeployProject>;
+  writeLink: (link: ProjectLink, root: string) => Promise<void>;
+  writeViteApiUrl: (projectApiUrl: string, root: string) => Promise<void>;
+  hasAppsFePackageJson: (root: string) => Promise<boolean>;
+  starbaseUrl: () => string;
+  projectNameFromPath: (root: string) => string;
+  promptName: (defaultName: string) => Promise<string>;
+};
+
+function resolveProjectName(raw: string | undefined, fallback: string): string {
+  const trimmed = raw?.trim() ?? "";
+  return (trimmed || fallback).slice(0, 80);
+}
+
+/** Creates and writes a project link when the folder is not linked yet. */
+export async function ensureDeployLink(
+  input: EnsureDeployLinkInput,
+  deps: EnsureDeployLinkDeps,
+): Promise<ProjectLink> {
+  const existing = await deps.readLink(input.root);
+  if (existing) return existing;
+
+  await deps.ensureAuth();
+  await deps.collectFiles(input.root);
+
+  const flaggedName = input.name?.trim() ?? "";
+  if (!input.isTty && !flaggedName) {
+    throw new Error(UNLINKED_NON_TTY_MESSAGE);
+  }
+
+  const organizationId = await deps.resolveOrganization(input.orgId);
+  const defaultName = deps.projectNameFromPath(input.root);
+  const name = flaggedName
+    ? resolveProjectName(flaggedName, defaultName)
+    : resolveProjectName(await deps.promptName(defaultName), defaultName);
+
+  const project = await deps.createProject(organizationId ? { name, organizationId } : { name });
+  const wantFrontend = await deps.hasAppsFePackageJson(input.root);
+  const link: ProjectLink = {
+    projectId: project.id,
+    apiUrl: deps.starbaseUrl(),
+    projectApiUrl: project.apiUrl,
+    ...(wantFrontend ? { frontend: defaultFrontendConfig() } : {}),
+  };
+  await deps.writeLink(link, input.root);
+  await deps.writeViteApiUrl(project.apiUrl, input.root);
+  return link;
+}

package/src/index.ts

@@ -36,6 +36,8 @@ import {
   type Starter,
 } from "./emit-starter.js";
 import { parseCreateArgs } from "./parse-create-args.js";
+import { parseDeployArgs } from "./parse-deploy-args.js";
+import { ensureDeployLink } from "./ensure-deploy-link.js";
 import { printLiveUrl } from "./print-live-url.js";
 
 const execFileAsync = promisify(execFile);
@@ -52,7 +54,7 @@ Commands:
   projects             List your projects
   create [path] [--starter <id>] [--empty] [--org <id>]  Create a project, scaffold a starter, and deploy
   link [projectId]     Write robodev/.robodev in the current folder
-  deploy [--force]     Deploy schema, APIs, jobs, and frontend (local Vite build when .robodev frontend is set)
+  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
 
 dev options:
@@ -247,12 +249,31 @@ async function collectDeployFiles(
 async function runDeploy(
   forceFlag: boolean,
   options: DeployOptions = {},
+  flags: { name?: string; orgId?: string } = {},
 ): Promise<string | undefined> {
   const root = options.root ?? process.cwd();
-  const link = await readLink(root);
-  if (!link) {
-    throw new Error("No robodev/.robodev file. Run `robodev link` or `robodev create` first.");
-  }
+  const link = await ensureDeployLink(
+    { root, name: flags.name, orgId: flags.orgId, isTty: Boolean(stdin.isTTY) },
+    {
+      readLink,
+      collectFiles,
+      ensureAuth: async () => {
+        await authed("/v1/auth/me");
+      },
+      resolveOrganization,
+      createProject: (body) =>
+        authed<Project>("/v1/projects", {
+          method: "POST",
+          body: JSON.stringify(body),
+        }),
+      writeLink,
+      writeViteApiUrl,
+      hasAppsFePackageJson,
+      starbaseUrl,
+      projectNameFromPath,
+      promptName: (defaultName) => prompt(`Project name [${defaultName}]: `),
+    },
+  );
   const files = await collectDeployFiles(root, link, options);
   let force = forceFlag;
 
@@ -631,9 +652,11 @@ async function main(): Promise<void> {
     case "link":
       await runLink(args[0]);
       break;
-    case "deploy":
-      await runDeploy(args.includes("--force"));
+    case "deploy": {
+      const parsed = parseDeployArgs(args);
+      await runDeploy(parsed.force, {}, { name: parsed.name, orgId: parsed.orgId });
       break;
+    }
     case "dev": {
       const { main: runDev } = await import("./dev.js");
       await runDev(args);

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

@@ -24,3 +24,10 @@ test("parseCreateArgs rejects a missing --org value", () => {
 test("parseCreateArgs rejects unknown flags including --organization", () => {
   assert.throws(() => parseCreateArgs(["--organization", "org_1"]), /Unknown flag --organization/);
 });
+
+test("parseCreateArgs rejects --empty together with --starter", () => {
+  assert.throws(
+    () => parseCreateArgs(["--empty", "--starter", "empty"]),
+    /Use either --empty or --starter, not both/,
+  );
+});

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

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseDeployArgs } from "./parse-deploy-args.js";
+
+test("parseDeployArgs accepts --force --name and --org", () => {
+  assert.deepEqual(parseDeployArgs([]), { force: false, name: undefined, orgId: undefined });
+  assert.deepEqual(parseDeployArgs(["--force"]), {
+    force: true,
+    name: undefined,
+    orgId: undefined,
+  });
+  assert.deepEqual(parseDeployArgs(["--name", "Orbit", "--org", "org_1"]), {
+    force: false,
+    name: "Orbit",
+    orgId: "org_1",
+  });
+  assert.deepEqual(parseDeployArgs(["--name=Orbit", "--org=org_2", "--force"]), {
+    force: true,
+    name: "Orbit",
+    orgId: "org_2",
+  });
+});
+
+test("parseDeployArgs rejects a missing --name or --org value", () => {
+  assert.throws(() => parseDeployArgs(["--name"]), /Missing value for --name/);
+  assert.throws(() => parseDeployArgs(["--name="]), /Missing value for --name/);
+  assert.throws(() => parseDeployArgs(["--name", "--force"]), /Missing value for --name/);
+  assert.throws(() => parseDeployArgs(["--org"]), /Missing value for --org/);
+  assert.throws(() => parseDeployArgs(["--org="]), /Missing value for --org/);
+  assert.throws(() => parseDeployArgs(["--org", "--name", "x"]), /Missing value for --org/);
+});
+
+test("parseDeployArgs rejects unknown flags the same way as create", () => {
+  assert.throws(() => parseDeployArgs(["--organization", "org_1"]), /Unknown flag --organization/);
+  assert.throws(() => parseDeployArgs(["--empty"]), /Unknown flag --empty/);
+  assert.throws(() => parseDeployArgs(["my-app"]), /Unexpected argument my-app/);
+});

package/src/parse-deploy-args.ts

@@ -0,0 +1,53 @@
+export type DeployArgs = { force: boolean; name?: string; orgId?: string };
+
+export function parseDeployArgs(args: string[]): DeployArgs {
+  let force = false;
+  let name: string | undefined;
+  let orgId: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (arg === "--name") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Missing value for --name");
+      }
+      name = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--name=")) {
+      const value = arg.slice("--name=".length);
+      if (!value) {
+        throw new Error("Missing value for --name");
+      }
+      name = value;
+      continue;
+    }
+    if (arg === "--org") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("Missing value for --org");
+      }
+      orgId = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--org=")) {
+      const value = arg.slice("--org=".length);
+      if (!value) {
+        throw new Error("Missing value for --org");
+      }
+      orgId = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown flag ${arg}`);
+    }
+    throw new Error(`Unexpected argument ${arg}`);
+  }
+  return { force, name, orgId };
+}

package/templates/auth-chat/package.json

@@ -9,10 +9,10 @@
     "rules:gen": "rulesync generate"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.12.0"
+    "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.38.0",
+    "robodev": "^0.39.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/backend/package.json

@@ -8,10 +8,10 @@
     "deploy": "robodev deploy"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.12.0"
+    "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.38.0",
+    "robodev": "^0.39.0",
     "typescript": "^5.9.2"
   }
 }

package/templates/empty/package.json

@@ -8,10 +8,10 @@
     "deploy": "robodev deploy"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.12.0"
+    "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.38.0",
+    "robodev": "^0.39.0",
     "typescript": "^5.9.2"
   }
 }

package/templates/marketplace/package.json

@@ -9,10 +9,10 @@
     "rules:gen": "rulesync generate"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.12.0"
+    "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.38.0",
+    "robodev": "^0.39.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/space/package.json

@@ -9,10 +9,10 @@
     "rules:gen": "rulesync generate"
   },
   "dependencies": {
-    "@robodev-ai/sdk": "^0.12.0"
+    "@robodev-ai/sdk": "^0.13.0"
   },
   "devDependencies": {
-    "robodev": "^0.38.0",
+    "robodev": "^0.39.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }