@vocoder/cli 0.1.13 → 0.1.15

package/dist/bin.mjs

@@ -831,8 +831,9 @@ var VocoderAPI = class {
   }
   // ── Project lookup ────────────────────────────────────────────────────────────
   /**
-   * Look up whether a project already exists for a given repo + scope.
-   * Returns { projectId, projectName, organizationName } or null if not found.
+   * Look up all project apps for a given repo. Returns info about exact matches,
+   * existing apps in other scopes, and whether a whole-repo app exists.
+   * No auth required.
    */
   async lookupProjectByRepo(params) {
     try {
@@ -844,13 +845,37 @@ var VocoderAPI = class {
           scopePath: params.scopePath
         })
       });
-      if (response.status === 404) return null;
-      if (!response.ok) return null;
+      if (!response.ok) {
+        return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
+      }
       return await response.json();
     } catch {
-      return null;
+      return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
     }
   }
+  /**
+   * Add a new ProjectApp to an existing project (monorepo: new app directory).
+   * Does not check plan limits — no new project is created.
+   */
+  async createProjectApp(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/project/apps`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${userToken}`
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to create project app (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
 };
 
 // src/commands/init.ts
@@ -1499,6 +1524,119 @@ async function runProjectCreate(params) {
     return null;
   }
 }
+async function runProjectAppCreate(params) {
+  const { api, userToken, projectId, projectName, repoCanonical } = params;
+  const existingScopes = new Set(params.existingApps.map((a) => a.scopePath));
+  let rawLocales;
+  try {
+    rawLocales = await api.listLocales(userToken);
+  } catch {
+    p3.log.error("Failed to fetch supported locales. Check your connection and try again.");
+    return null;
+  }
+  const languageOptions = buildLanguageOptions(rawLocales);
+  const localeOptions = buildLocaleOptions(rawLocales);
+  let scopePath;
+  if (params.defaultScopePath && !existingScopes.has(params.defaultScopePath)) {
+    scopePath = params.defaultScopePath;
+    p3.log.success(`App directory: ${chalk4.bold(scopePath)}`);
+  } else {
+    if (params.existingApps.length > 0) {
+      const configuredList = params.existingApps.map((a) => chalk4.dim(a.scopePath || "(entire repo)")).join(", ");
+      p3.log.info(`Already configured: ${configuredList}`);
+    }
+    const hasWholeRepoApp = existingScopes.has("");
+    const rawScope = await p3.text({
+      message: "App directory for this new app",
+      placeholder: "e.g. apps/backend",
+      initialValue: params.defaultScopePath ?? "",
+      validate(value) {
+        const v = value.trim();
+        if (!v && hasWholeRepoApp) return "This project already covers the entire repo.";
+        if (!v) return "App directory is required when other apps already exist.";
+        if (v.startsWith("/")) return "Use a relative path, not an absolute path.";
+        if (v.includes("..")) return 'Path must not contain "..".';
+        if (existingScopes.has(v)) return `"${v}" is already configured. Choose a different directory.`;
+      }
+    });
+    if (p3.isCancel(rawScope)) return null;
+    scopePath = (rawScope ?? "").trim();
+  }
+  const sourceLocale = await searchSelectLocale(
+    languageOptions,
+    "Source language",
+    "en"
+  );
+  if (sourceLocale === null) return null;
+  const targetOptions = localeOptions.filter((opt) => opt.bcp47 !== sourceLocale);
+  const targetLocales = await searchMultiSelectLocales(
+    targetOptions,
+    "Target languages"
+  );
+  if (targetLocales === null) return null;
+  if (targetLocales.length === 0) {
+    p3.log.warn("No target languages selected \u2014 you can add them later from the dashboard.");
+  }
+  const triggerChoice = await p3.select({
+    message: "When should translations run?",
+    options: [
+      { value: "push", label: "On push to target branches" },
+      { value: "pull_request", label: "On pull requests" },
+      { value: "push_and_pr", label: "On push and pull requests" },
+      { value: "manual", label: "Manual only", hint: "use vocoder sync or trigger from dashboard" }
+    ]
+  });
+  if (p3.isCancel(triggerChoice)) return null;
+  const triggersForBranch = triggerChoice === "push_and_pr" ? ["push", "pull_request"] : [triggerChoice];
+  const detected = detectGitBranches();
+  let selectedBranches = [];
+  {
+    let initial = [detected.defaultBranch];
+    while (selectedBranches.length === 0) {
+      const result = await filterableBranchSelect({
+        message: "Target branches",
+        branches: detected.branches,
+        defaultBranch: detected.defaultBranch,
+        initialValues: initial
+      });
+      if (result === null) return null;
+      if (result.length === 0) {
+        p3.log.warn("At least one branch is required.");
+        initial = [detected.defaultBranch];
+      } else {
+        selectedBranches = result;
+      }
+    }
+  }
+  const branchTriggers = selectedBranches.map((pattern) => ({
+    pattern,
+    triggers: triggersForBranch
+  }));
+  try {
+    const result = await api.createProjectApp(userToken, {
+      projectId,
+      scopePath,
+      sourceLocale,
+      targetLocales,
+      branchTriggers,
+      repoCanonical: repoCanonical ?? ""
+    });
+    p3.log.success(`App ${chalk4.bold(scopePath)} added to ${chalk4.bold(projectName)}!`);
+    return {
+      projectId: result.projectId,
+      projectName: result.projectName,
+      apiKey: result.apiKey,
+      scopePath: result.scopePath,
+      sourceLocale,
+      targetLocales,
+      branchTriggers
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    p3.log.error(`Failed to add app: ${message}`);
+    return null;
+  }
+}
 
 // src/utils/workspace.ts
 import * as p4 from "@clack/prompts";
@@ -1848,22 +1986,44 @@ async function init(options = {}) {
         p5.log.warn(warning);
       }
     }
+    let existingAppsForRepo = [];
+    let repoProjectId = null;
+    let repoProjectName = null;
     if (identity) {
       const anonApi = new VocoderAPI({ apiUrl, apiKey: "" });
-      const existing = await anonApi.lookupProjectByRepo({
+      const lookup = await anonApi.lookupProjectByRepo({
         repoCanonical: identity.repoCanonical,
         scopePath: identity.repoScopePath
       });
-      if (existing) {
+      if (lookup.exactMatch) {
+        const { exactMatch } = lookup;
         runScaffold({
-          projectName: existing.projectName,
-          organizationName: existing.organizationName,
-          sourceLocale: existing.sourceLocale ?? "en",
-          branchTriggers: existing.branchTriggers ?? [{ pattern: "main", triggers: ["push"] }]
+          projectName: exactMatch.projectName,
+          organizationName: exactMatch.organizationName,
+          sourceLocale: exactMatch.sourceLocale ?? "en",
+          branchTriggers: exactMatch.branchTriggers ?? [{ pattern: "main", triggers: ["push"] }]
         });
         p5.outro("Vocoder is already set up for this repository.");
         return 0;
       }
+      if (lookup.hasWholeRepoApp) {
+        const wholeRepo = lookup.existingApps.find((a) => a.scopePath === "");
+        if (wholeRepo) {
+          runScaffold({
+            projectName: wholeRepo.projectName,
+            organizationName: wholeRepo.organizationName,
+            sourceLocale: "en",
+            branchTriggers: [{ pattern: "main", triggers: ["push"] }]
+          });
+          p5.outro("Vocoder is already set up for this repository.");
+          return 0;
+        }
+      }
+      if (lookup.existingApps.length > 0) {
+        existingAppsForRepo = lookup.existingApps;
+        repoProjectId = lookup.existingApps[0]?.projectId ?? null;
+        repoProjectName = lookup.existingApps[0]?.projectName ?? null;
+      }
     }
     const api = new VocoderAPI({ apiUrl, apiKey: "" });
     let userToken;
@@ -2137,6 +2297,34 @@ async function init(options = {}) {
         }
       }
     }
+    if (repoProjectId && repoProjectName && existingAppsForRepo.length > 0) {
+      p5.log.info(
+        `${chalk6.bold(repoProjectName)} is already set up for this repo.
+  Configured apps: ${existingAppsForRepo.map((a) => chalk6.cyan(a.scopePath || "(entire repo)")).join(", ")}`
+      );
+      const appResult = await runProjectAppCreate({
+        api,
+        userToken,
+        projectId: repoProjectId,
+        projectName: repoProjectName,
+        organizationName: selectedWorkspaceName,
+        repoCanonical: identity?.repoCanonical,
+        defaultScopePath: identity?.repoScopePath,
+        existingApps: existingAppsForRepo
+      });
+      if (!appResult) {
+        p5.log.error("App setup failed. Run `vocoder init` again.");
+        return 1;
+      }
+      runScaffold({
+        projectName: appResult.projectName,
+        organizationName: selectedWorkspaceName,
+        sourceLocale: appResult.sourceLocale,
+        branchTriggers: appResult.branchTriggers
+      });
+      p5.outro("You're all set.");
+      return 0;
+    }
     try {
       const wsCheck = await api.listWorkspaces(userToken);
       const ws = wsCheck.workspaces.find((w) => w.id === selectedWorkspaceId);
@@ -2144,13 +2332,19 @@ async function init(options = {}) {
         p5.log.warn(
           `Project limit reached \u2014 ${ws.projectCount}/${ws.maxProjects} on your ${chalk6.bold(ws.planId)} plan.`
         );
+        const hasRepoContext = !!identity?.repoCanonical;
+        const options2 = [];
+        if (hasRepoContext) {
+          options2.push({
+            value: "connect",
+            label: "Connect this repo to an existing project"
+          });
+        }
+        options2.push({ value: "upgrade", label: "Upgrade plan" });
+        options2.push({ value: "cancel", label: "Cancel" });
         const limitAction = await p5.select({
           message: "What would you like to do?",
-          options: [
-            { value: "upgrade", label: "Upgrade plan" },
-            { value: "existing", label: "Use an existing project in this workspace" },
-            { value: "cancel", label: "Cancel" }
-          ]
+          options: options2
         });
         if (p5.isCancel(limitAction) || limitAction === "cancel") {
           p5.cancel("Setup cancelled.");
@@ -2167,11 +2361,10 @@ async function init(options = {}) {
           return 1;
         }
         const chosenId = await p5.select({
-          message: "Select a project",
+          message: "Which project should this repo be connected to?",
           options: existingProjects.map((proj) => ({
             value: proj.id,
-            label: proj.name,
-            hint: `${proj.sourceLocale} \u2192 ${proj.targetLocales.join(", ")}`
+            label: proj.name
           }))
         });
         if (p5.isCancel(chosenId)) {
@@ -2179,16 +2372,26 @@ async function init(options = {}) {
           return 1;
         }
         const chosen = existingProjects.find((proj) => proj.id === chosenId);
-        runScaffold({
+        const appResult = await runProjectAppCreate({
+          api,
+          userToken,
+          projectId: chosen.id,
           projectName: chosen.name,
           organizationName: selectedWorkspaceName,
-          sourceLocale: chosen.sourceLocale,
-          branchTriggers: chosen.branchTriggers ?? [{ pattern: "main", triggers: ["push"] }]
+          repoCanonical: identity?.repoCanonical,
+          defaultScopePath: identity?.repoScopePath,
+          existingApps: []
+        });
+        if (!appResult) {
+          p5.log.error("Setup failed. Run `vocoder init` again.");
+          return 1;
+        }
+        runScaffold({
+          projectName: appResult.projectName,
+          organizationName: selectedWorkspaceName,
+          sourceLocale: appResult.sourceLocale,
+          branchTriggers: appResult.branchTriggers
         });
-        p5.log.info(
-          `Get your project API key at:
-  ${apiUrl}/dashboard/projects/${chosen.id}/settings`
-        );
         p5.outro("You're all set.");
         return 0;
       }