@cimplify/sdk 0.44.33 → 0.44.34

package/dist/cli/commands/projects.mjs

@@ -12,13 +12,42 @@ var CLI_ERROR_CODE = {
   ALREADY_LINKED: "ALREADY_LINKED",
   SERVER_ERROR: "SERVER_ERROR"};
 var EXIT_CODE = {
-  ERROR: 1};
+  ABORTED: 3,
+  NOT_LINKED: 4,
+  ALREADY_LINKED: 5,
+  GIT_ERROR: 6,
+  INTERACTIVE_REQUIRED: 7,
+  PROJECT_NOT_FOUND: 8,
+  NETWORK_ERROR: 10,
+  SERVER_ERROR: 11,
+  TIMEOUT: 12,
+  NOT_LOGGED_IN: 20,
+  AUTH_FAILED: 21,
+  UNAUTHORIZED: 22,
+  INVALID_INPUT: 30
+};
+var EXIT_CODE_FOR = {
+  NOT_LOGGED_IN: EXIT_CODE.NOT_LOGGED_IN,
+  NOT_LINKED: EXIT_CODE.NOT_LINKED,
+  NETWORK_ERROR: EXIT_CODE.NETWORK_ERROR,
+  AUTH_FAILED: EXIT_CODE.AUTH_FAILED,
+  PROJECT_NOT_FOUND: EXIT_CODE.PROJECT_NOT_FOUND,
+  GIT_ERROR: EXIT_CODE.GIT_ERROR,
+  INVALID_INPUT: EXIT_CODE.INVALID_INPUT,
+  ALREADY_LINKED: EXIT_CODE.ALREADY_LINKED,
+  SERVER_ERROR: EXIT_CODE.SERVER_ERROR,
+  ABORTED: EXIT_CODE.ABORTED,
+  UNAUTHORIZED: EXIT_CODE.UNAUTHORIZED,
+  TIMEOUT: EXIT_CODE.TIMEOUT,
+  INTERACTIVE_REQUIRED: EXIT_CODE.INTERACTIVE_REQUIRED
+};
 var CliError = class extends Error {
-  constructor(code, message, exitCode = EXIT_CODE.ERROR) {
+  constructor(code, message, options = {}) {
     super(message);
     this.name = "CliError";
     this.code = code;
-    this.exitCode = exitCode;
+    this.exitCode = options.exitCode ?? EXIT_CODE_FOR[code];
+    this.remediation = options.remediation;
   }
 };
 
@@ -196,6 +225,13 @@ function parseArgs(argv) {
   }
   return { positional, flags };
 }
+function flagString(args, name) {
+  const v = args.flags.get(name);
+  return typeof v === "string" ? v : void 0;
+}
+function flagBool(args, name) {
+  return args.flags.has(name);
+}
 var AUTH_FILE_NAME = "auth.json";
 var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
 var APP_CONFIG_DIR_NAME = "cimplify";
@@ -234,34 +270,79 @@ var BOLD_OPEN = "\x1B[1m";
 var DIM_OPEN = "\x1B[2m";
 var GREEN_OPEN = "\x1B[32m";
 var PREFIX_SUCCESS = "\u2713";
+var ENV_JSON = "CIMPLIFY_JSON";
+function envFlag(name) {
+  const v = process.env[name];
+  return v === "1" || v === "true";
+}
+function isJsonMode() {
+  return envFlag(ENV_JSON);
+}
 function wrap(open, value) {
   return `${open}${value}${RESET}`;
 }
 function bold(value) {
-  return wrap(BOLD_OPEN, value);
+  return isJsonMode() ? value : wrap(BOLD_OPEN, value);
 }
 function dim(value) {
-  return wrap(DIM_OPEN, value);
+  return isJsonMode() ? value : wrap(DIM_OPEN, value);
 }
 function green(value) {
-  return wrap(GREEN_OPEN, value);
+  return isJsonMode() ? value : wrap(GREEN_OPEN, value);
 }
 function success(message) {
+  if (isJsonMode()) return;
   console.log(`${green(PREFIX_SUCCESS)} ${message}`);
 }
 function info(message) {
+  if (isJsonMode()) return;
   console.log(message);
 }
+var ENV_EMITTED = "__CIMPLIFY_RESULT_EMITTED";
+function result(data) {
+  if (!isJsonMode()) return;
+  if (process.env[ENV_EMITTED] === "1") return;
+  process.env[ENV_EMITTED] = "1";
+  process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+}
+var REPO_PROVIDER = {
+  FREESTYLE: "freestyle",
+  GITHUB: "github",
+  GITEA: "gitea",
+  EXTERNAL: "external"
+};
+new Set(Object.values(REPO_PROVIDER));
 
 // src/cli/commands/projects.ts
 var SUB_LS = "ls";
 var SUB_LIST = "list";
 var SUB_CREATE = "create";
+var FLAG_NO_REPO = "no-repo";
+var FLAG_CONNECT = "connect";
 var PROJECT_TYPE_DEFAULT = "nextjs-app";
 var COL_GAP = "  ";
 function projectsEndpoint(businessId) {
   return `/v1/businesses/${encodeURIComponent(businessId)}/projects`;
 }
+function provisionRepoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo/provision`;
+}
+function connectRepoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo/connect`;
+}
+function detectProviderFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "git.freestyle.sh") return REPO_PROVIDER.FREESTYLE;
+    if (parsed.hostname === "github.com" || parsed.hostname.endsWith(".github.com")) {
+      return REPO_PROVIDER.GITHUB;
+    }
+    if (parsed.hostname.includes("gitea")) return REPO_PROVIDER.GITEA;
+  } catch {
+  }
+  return REPO_PROVIDER.EXTERNAL;
+}
 async function run(argv) {
   const args = parseArgs(argv);
   const sub = args.positional[0];
@@ -282,10 +363,13 @@ async function run(argv) {
     if (!name) {
       throw new CliError(
         CLI_ERROR_CODE.INVALID_INPUT,
-        `Usage: cimplify projects ${SUB_CREATE} <name>`
+        `Usage: cimplify projects ${SUB_CREATE} <name> [--no-repo | --connect <url>]`
       );
     }
-    await createProject(client, auth.businessId, name);
+    await createProject(client, auth.businessId, name, {
+      noRepo: flagBool(args, FLAG_NO_REPO),
+      connectRemote: flagString(args, FLAG_CONNECT)
+    });
     return;
   }
   throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown subcommand "${sub}"`);
@@ -294,6 +378,7 @@ async function listProjects(client, businessId) {
   const projects = await client.get(projectsEndpoint(businessId));
   if (projects.length === 0) {
     info(dim("No projects yet. Create one: `cimplify projects create <name>`"));
+    result({ projects: [] });
     return;
   }
   const idWidth = Math.max(...projects.map((p) => p.id.length));
@@ -316,12 +401,73 @@ async function listProjects(client, businessId) {
       ].join(COL_GAP)
     );
   }
+  result({
+    projects: projects.map((p) => ({
+      id: p.id,
+      name: p.name,
+      project_type: p.project_type ?? null
+    }))
+  });
 }
-async function createProject(client, businessId, name) {
+async function createProject(client, businessId, name, options = {}) {
+  if (options.noRepo && options.connectRemote) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      "Cannot pass both --no-repo and --connect."
+    );
+  }
   const body = { name, project_type: PROJECT_TYPE_DEFAULT };
   const project = await client.post(projectsEndpoint(businessId), body);
   success(`Created project ${project.name} (${project.id})`);
-  info(dim(`Link it: cimplify link ${project.id}`));
+  if (options.noRepo) {
+    info(dim("Skipped repo provisioning (--no-repo). Use `cimplify repo provision` later."));
+    info(dim(`Link locally: cimplify link ${project.id}`));
+    result({
+      project: { id: project.id, name: project.name },
+      repo: null
+    });
+    return;
+  }
+  if (options.connectRemote) {
+    const provider = detectProviderFromUrl(options.connectRemote);
+    if (provider === REPO_PROVIDER.FREESTYLE) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        "Cannot connect a Freestyle URL \u2014 Freestyle repos are provisioned, not connected."
+      );
+    }
+    const repoBody = {
+      provider,
+      remote_url: options.connectRemote
+    };
+    const repo2 = await client.post(
+      connectRepoEndpoint(businessId, project.id),
+      repoBody
+    );
+    success(`Connected ${repo2.provider} remote ${repo2.remote_url}`);
+    info(dim(`Link locally: cimplify link ${project.id}`));
+    result({
+      project: { id: project.id, name: project.name },
+      repo: { provider: repo2.provider, id: repo2.id, remote_url: repo2.remote_url, default_branch: repo2.default_branch }
+    });
+    return;
+  }
+  const repo = await client.post(
+    provisionRepoEndpoint(businessId, project.id),
+    {}
+  );
+  success(`Provisioned ${repo.provider} repo`);
+  info(dim(`  remote: ${repo.remote_url}`));
+  info("");
+  info(dim("Wire your local repo:"));
+  info(dim(`  cimplify link ${project.id}`));
+  info(dim(`  git init && git remote add origin ${repo.remote_url}`));
+  info(dim(`  git add . && git commit -m "Initial commit"`));
+  info(dim(`  cimplify deploy`));
+  result({
+    project: { id: project.id, name: project.name },
+    repo: { provider: repo.provider, id: repo.id, remote_url: repo.remote_url, default_branch: repo.default_branch }
+  });
 }
 
-export { run as default };
+export { run as default, detectProviderFromUrl };