@lizard-build/cli 0.1.0 → 0.3.30

package/src/commands/init.ts

@@ -1,12 +1,12 @@
-import fs from "node:fs";
-import path from "node:path";
 import chalk from "chalk";
+import path from "node:path";
 import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
+import { api, withQuery, type Workspace } from "../lib/api.js";
 import {
-  findProjectConfig,
-  saveProjectConfig,
+  getProjectLink,
+  setProjectLink,
+  type ProjectLink,
 } from "../lib/config.js";
 import {
   success,
@@ -15,125 +15,174 @@ import {
   printJSON,
   isTTY,
 } from "../lib/format.js";
+import { fetchWorkspaces, pickWorkspace } from "../lib/picker.js";
 
 interface Project {
   id: string;
   name: string;
   slug: string;
+  workspaceId?: string | null;
 }
 
-/** Detect framework from files in cwd */
-function detectFramework(): {
-  name: string;
-  port: number;
-  buildCmd: string;
-  startCmd: string;
-} | null {
-  const cwd = process.cwd();
-  const has = (f: string) => fs.existsSync(path.join(cwd, f));
+/**
+ * Ensure the current directory is linked to a project. If already linked and
+ * `force` is false, returns the existing link. Otherwise runs the
+ * create-or-select flow.
+ *
+ * Flow (mirrors Railway's `link` wizard):
+ *   1. Workspace — selected by --workspace, single workspace auto-pick,
+ *      or interactive select. Skipped when only one workspace exists.
+ *   2. Project — matched by --name within the workspace, picked from the
+ *      workspace's project list, or created.
+ *
+ * `projectName` (from --name / --project) is matched against existing
+ * projects inside the resolved workspace; if not found, a new project
+ * with that name is created in the resolved workspace.
+ */
+export async function ensureLinked(opts: {
+  projectName?: string;
+  workspaceFlag?: string;
+  force?: boolean;
+  relinkPrompt?: boolean;
+} = {}): Promise<ProjectLink> {
+  const existing = getProjectLink();
 
-  if (has("next.config.js") || has("next.config.mjs") || has("next.config.ts"))
-    return { name: "Next.js", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
-  if (has("nuxt.config.ts") || has("nuxt.config.js"))
-    return { name: "Nuxt", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
-  if (has("remix.config.js") || has("remix.config.ts"))
-    return { name: "Remix", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
-  if (has("astro.config.mjs") || has("astro.config.ts"))
-    return { name: "Astro", port: 4321, buildCmd: "npm run build", startCmd: "npm start" };
-  if (has("vite.config.ts") || has("vite.config.js"))
-    return { name: "Vite", port: 3000, buildCmd: "npm run build", startCmd: "npm run preview" };
-  if (has("Dockerfile"))
-    return { name: "Docker", port: 8080, buildCmd: "", startCmd: "" };
-  if (has("go.mod"))
-    return { name: "Go", port: 8080, buildCmd: "go build -o app .", startCmd: "./app" };
-  if (has("requirements.txt") || has("pyproject.toml"))
-    return { name: "Python", port: 8000, buildCmd: "pip install -r requirements.txt", startCmd: "python app.py" };
-  if (has("package.json"))
-    return { name: "Node.js", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
-  return null;
-}
+  if (existing && !opts.force) {
+    if (!opts.relinkPrompt) return existing;
+
+    if (!isTTY()) {
+      throw new Error(
+        `Already linked to ${existing.projectName || existing.projectId}. Use --force to relink.`,
+      );
+    }
+    const proceed = await p.confirm({
+      message: `Directory is linked to "${existing.projectName || existing.projectId}". Relink?`,
+      initialValue: false,
+    });
+    if (p.isCancel(proceed) || !proceed) return existing;
+  }
 
-function writeLizardToml(
-  framework: { name: string; port: number; buildCmd: string; startCmd: string } | null,
-) {
-  const port = framework?.port ?? 3000;
-  const build = framework?.buildCmd ?? "";
-  const start = framework?.startCmd ?? "";
+  // 1. Workspace
+  const workspaces = await fetchWorkspaces();
+  const workspace = await pickWorkspace({
+    flag: opts.workspaceFlag,
+    projectNameHint: opts.projectName,
+    workspaces,
+  });
 
-  let toml = `# lizard.toml\n\n`;
-  if (build) toml += `[build]\ncommand = "${build}"\n\n`;
-  toml += `[deploy]\nport = ${port}\n`;
-  if (start) toml += `start_command = "${start}"\n`;
-  toml += `\n[resources]\ncpu = 1\nmemory = 512\n`;
+  // 2. Project — pulled from the chosen workspace only
+  const projects = await api.get<Project[]>(
+    withQuery("/api/projects", { workspaceId: workspace.id }),
+  );
 
-  const tomlPath = path.join(process.cwd(), "lizard.toml");
-  if (!fs.existsSync(tomlPath)) {
-    fs.writeFileSync(tomlPath, toml);
+  let project: Project;
+
+  if (opts.projectName) {
+    const lower = opts.projectName.toLowerCase();
+    const match = projects.find(
+      (pr) =>
+        pr.name.toLowerCase() === lower ||
+        pr.slug.toLowerCase() === lower ||
+        pr.id.toLowerCase() === lower,
+    );
+    project =
+      match ??
+      (await api.post<Project>("/api/projects", {
+        name: opts.projectName,
+        workspaceId: workspace.id,
+      }));
+  } else if (!isTTY()) {
+    project = await api.post<Project>("/api/projects", {
+      name: path.basename(process.cwd()),
+      workspaceId: workspace.id,
+    });
+  } else {
+    let action: "create" | "select" = "create";
+    if (projects.length > 0) {
+      const choice = await p.select({
+        message: `Link a project in ${workspace.name}`,
+        options: [
+          { value: "create", label: "Create new project" },
+          { value: "select", label: "Select existing project" },
+        ],
+      });
+      if (p.isCancel(choice)) process.exit(5);
+      action = choice as "create" | "select";
+    }
+
+    if (action === "create") {
+      const nameRes = await p.text({
+        message: "Project name",
+        defaultValue: path.basename(process.cwd()),
+        placeholder: path.basename(process.cwd()),
+      });
+      if (p.isCancel(nameRes)) process.exit(5);
+      project = await api.post<Project>("/api/projects", {
+        name: nameRes as string,
+        workspaceId: workspace.id,
+      });
+    } else {
+      const selected = await p.select({
+        message: "Select project",
+        options: projects.map((pr) => ({
+          value: pr.id,
+          label: pr.name,
+          hint: pr.id,
+        })),
+      });
+      if (p.isCancel(selected)) process.exit(5);
+      project = projects.find((pr) => pr.id === selected)!;
+    }
   }
+
+  const link: ProjectLink = {
+    projectId: project.id,
+    projectName: project.name,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+  };
+  setProjectLink(link);
+  return link;
 }
 
 export function registerInit(program: Command) {
   program
     .command("init")
-    .description("Create a new project and link current directory")
-    .option("--name <name>", "Project name")
+    .description(
+      "Create or select a project and link it to the current directory",
+    )
+    .option("-n, --name <name>", "Project name (use existing or create if missing)")
+    .option("--project <name>", "Alias for --name (kept for backwards compat)")
+    .option("-w, --workspace <ws>", "Workspace id, slug, or name")
+    .option("--force", "Relink even if this directory is already linked")
     .action(async (opts) => {
-      // Check if already initialized
-      const existing = findProjectConfig();
-      if (existing) {
-        throw new Error(
-          "Already initialized. Run `lizard link` to change project.",
-        );
-      }
-
-      // Detect framework
-      const framework = detectFramework();
-      if (framework && !isJSONMode()) {
-        info(`Detected framework: ${chalk.cyan(framework.name)}`);
-      }
-
-      // Get project name
-      let projectName = opts.name;
-      if (!projectName) {
-        if (!isTTY()) {
-          throw new Error("--name is required in non-interactive mode");
-        }
-        const result = await p.text({
-          message: "Project name",
-          defaultValue: path.basename(process.cwd()),
-          placeholder: path.basename(process.cwd()),
-        });
-        if (p.isCancel(result)) process.exit(5);
-        projectName = result as string;
-      }
-
-      // Create project via API
-      const project = await api.post<Project>("/api/projects", {
-        name: projectName,
-      });
-
-      // Save local config
-      saveProjectConfig({
-        projectId: project.id,
-        projectName: project.name,
+      const projectName = opts.name || opts.project;
+      const link = await ensureLinked({
+        projectName,
+        workspaceFlag: opts.workspace,
+        force: opts.force,
+        relinkPrompt: true,
       });
 
-      // Write lizard.toml
-      writeLizardToml(framework);
-
       if (isJSONMode()) {
         printJSON({
-          projectId: project.id,
-          name: project.name,
-          framework: framework?.name,
+          projectId: link.projectId,
+          name: link.projectName,
+          workspaceId: link.workspaceId,
+          workspaceName: link.workspaceName,
         });
       } else {
-        success(`Project "${chalk.bold(project.name)}" created`);
-        info(chalk.dim("  Linked to current directory"));
-        info(chalk.dim("  Config saved to .lizard/config.json"));
-        if (framework) {
-          info(chalk.dim(`  lizard.toml created for ${framework.name}`));
-        }
+        const wsLabel = link.workspaceName
+          ? chalk.dim(` (${link.workspaceName})`)
+          : "";
+        success(
+          `Linked to ${chalk.bold(link.projectName || link.projectId)}${wsLabel}`,
+        );
+        info(chalk.dim("  Saved to ~/.lizard/config.json"));
       }
     });
 }
+
+// Re-export Workspace so consumers can import the type from this module if
+// they ever want to (kept for older imports, harmless if unused).
+export type { Workspace };

package/src/commands/link.ts

@@ -1,63 +1,155 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { saveProjectConfig, findProjectConfig } from "../lib/config.js";
-import { success, isJSONMode, printJSON, isTTY } from "../lib/format.js";
+import { api, withQuery } from "../lib/api.js";
+import { setProjectLink, type ProjectLink } from "../lib/config.js";
+import { isJSONMode, printJSON, isTTY, success } from "../lib/format.js";
+import { fetchWorkspaces, pickWorkspace } from "../lib/picker.js";
 
 interface Project {
   id: string;
   name: string;
   slug: string;
+  workspaceId?: string | null;
 }
 
+interface ServiceInfo {
+  id: string;
+  name: string;
+  status?: string;
+}
+
+interface ServicesResponse {
+  apps?: ServiceInfo[];
+  addons?: ServiceInfo[];
+}
+
+/**
+ * `lizard link` — associates the current directory with an existing
+ * project and (optionally) service. Each piece can be passed via flags
+ * or selected interactively.
+ *
+ * Order matches Railway's wizard: workspace → project → service.
+ */
 export function registerLink(program: Command) {
   program
     .command("link")
-    .description("Link current directory to an existing project")
-    .option("--project <id>", "Project ID")
-    .action(async (opts) => {
-      let projectId = opts.project;
-      let projectName: string | undefined;
-
-      if (!projectId) {
-        // Fetch projects and let user pick
-        const projects = await api.get<Project[]>("/api/projects");
-        if (projects.length === 0) {
-          throw new Error("No projects found. Run `lizard init` to create one.");
-        }
+    .description("Associate the current directory with an existing project")
+    .argument("[service]", "Service name or ID (optional)")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("-w, --workspace <ws>", "Workspace id, slug, or name")
+    .option("-s, --service <name>", "Service name or ID (optional)")
+    .action(async (serviceArg: string | undefined, opts) => {
+      const projectFlag = opts.project;
+      const serviceFlag = serviceArg || opts.service;
+
+      // 1. Workspace
+      const workspaces = await fetchWorkspaces();
+      const workspace = await pickWorkspace({
+        flag: opts.workspace,
+        projectNameHint: projectFlag,
+        workspaces,
+      });
 
-        if (!isTTY()) {
+      // 2. Project (within workspace)
+      const projects = await api.get<Project[]>(
+        withQuery("/api/projects", { workspaceId: workspace.id }),
+      );
+      if (projects.length === 0) {
+        throw new Error(
+          `No projects in ${workspace.name}. Run \`lizard init\` to create one.`,
+        );
+      }
+      let project: Project;
+      if (projectFlag) {
+        const lower = projectFlag.toLowerCase();
+        const match = projects.find(
+          (pr) =>
+            pr.id.toLowerCase() === lower ||
+            pr.slug?.toLowerCase() === lower ||
+            pr.name.toLowerCase() === lower,
+        );
+        if (!match) {
           throw new Error(
-            "Use --project <id> in non-interactive mode. Available: " +
-              projects.map((p) => `${p.name} (${p.id})`).join(", "),
+            `Project "${projectFlag}" not found in ${workspace.name}. Available: ${projects.map((pr) => pr.name).join(", ")}`,
           );
         }
+        project = match;
+      } else if (projects.length === 1) {
+        project = projects[0];
+      } else {
+        if (!isTTY()) throw new Error("--project required in non-interactive mode");
+        const sel = await p.select({
+          message: `Select a project in ${workspace.name}`,
+          options: projects.map((pr) => ({ value: pr.id, label: pr.name, hint: pr.id })),
+        });
+        if (p.isCancel(sel)) process.exit(5);
+        project = projects.find((pr) => pr.id === sel)!;
+      }
 
-        const selected = await p.select({
-          message: "Select project",
-          options: projects.map((proj) => ({
-            value: proj.id,
-            label: proj.name,
-            hint: proj.id,
-          })),
+      // 3. Service (optional)
+      const services = await api
+        .get<ServicesResponse>(
+          withQuery(`/api/projects/${project.id}/services`, {
+            workspaceId: workspace.id,
+          }),
+        )
+        .catch(() => ({ apps: [], addons: [] }) as ServicesResponse);
+      const allServices = [
+        ...(services.apps || []),
+        ...(services.addons || []),
+      ];
+
+      let service: ServiceInfo | null = null;
+      if (serviceFlag) {
+        const lower = serviceFlag.toLowerCase();
+        service =
+          allServices.find(
+            (s) => s.id.toLowerCase() === lower || s.name?.toLowerCase() === lower,
+          ) || null;
+        if (!service) {
+          throw new Error(
+            `Service "${serviceFlag}" not found. Available: ${allServices.map((s) => s.name).join(", ")}`,
+          );
+        }
+      } else if (allServices.length > 0 && isTTY()) {
+        const choices = [
+          { value: "", label: "(none — link only project)" },
+          ...allServices.map((s) => ({ value: s.id, label: s.name, hint: s.status })),
+        ];
+        const sel = await p.select({
+          message: "Select a service (optional)",
+          options: choices,
         });
-        if (p.isCancel(selected)) process.exit(5);
-        projectId = selected as string;
-        projectName = projects.find((p) => p.id === projectId)?.name;
+        if (p.isCancel(sel)) process.exit(5);
+        if (sel) service = allServices.find((s) => s.id === sel)!;
       }
 
-      const old = findProjectConfig();
-      saveProjectConfig({ projectId, projectName });
+      // Save
+      const link: ProjectLink = {
+        projectId: project.id,
+        projectName: project.name,
+        workspaceId: workspace.id,
+        workspaceName: workspace.name,
+        serviceId: service?.id,
+        serviceName: service?.name,
+      };
+      setProjectLink(link);
 
       if (isJSONMode()) {
-        printJSON({ projectId, projectName });
-      } else if (old?.projectId && old.projectId !== projectId) {
+        printJSON({
+          projectId: link.projectId,
+          projectName: link.projectName,
+          workspaceId: link.workspaceId,
+          workspaceName: link.workspaceName,
+          serviceId: link.serviceId,
+          serviceName: link.serviceName,
+        });
+      } else {
+        const wsLabel = link.workspaceName ? chalk.dim(` (${link.workspaceName})`) : "";
         success(
-          `Relinked to ${chalk.bold(projectName || projectId)} (was ${old.projectName || old.projectId})`,
+          `Linked to ${chalk.bold(project.name)}${service ? ` / ${chalk.bold(service.name)}` : ""}${wsLabel}`,
         );
-      } else {
-        success(`Linked to ${chalk.bold(projectName || projectId)}`);
       }
     });
 }

package/src/commands/login.ts

@@ -131,15 +131,16 @@ export function registerLogin(program: Command) {
     .description("Log in to Lizard")
     .option("--token <token>", "Authenticate with an API token")
     .action(async (opts) => {
-      if (opts.token) {
+      const token = opts.token;
+      if (token) {
         // Direct token auth — validate it
         const res = await fetch(`${getBaseURL()}/api/auth/me`, {
-          headers: { Authorization: `Bearer ${opts.token}` },
+          headers: { Authorization: `Bearer ${token}` },
         });
         if (!res.ok) throw new Error("Invalid token");
         const user = (await res.json()) as any;
         saveCredentials({
-          accessToken: opts.token,
+          accessToken: token,
           userId: user.id,
           username: user.username,
           email: user.email,