@trycadence/cli 0.1.0 → 0.1.2

package/dist/cadence

@@ -1447,7 +1447,12 @@ function createCadenceClient(options = {}) {
     rpc,
     health: () => getCadenceHealth(healthOptions),
     auth: {
-      login: (input) => rpc.auth.login.mutate(input)
+      login: (input) => rpc.auth.login.mutate(input),
+      cli: {
+        start: (input) => rpc.auth.cli.start.mutate(input),
+        poll: (input) => rpc.auth.cli.poll.query(input),
+        complete: (input) => rpc.auth.cli.complete.mutate(input)
+      }
     },
     events: {
       list: (input) => rpc.events.list.query(input)
@@ -1481,6 +1486,11 @@ function createCadenceClient(options = {}) {
       create: (input) => rpc.changesets.create.mutate(input),
       get: (input) => rpc.changesets.get.query(input),
       list: (input) => rpc.changesets.list.query(input)
+    },
+    projects: {
+      default: () => rpc.projects.default.query(),
+      list: () => rpc.projects.list.query(),
+      resolve: (input) => rpc.projects.resolve.query(input)
     }
   };
 }
@@ -1494,6 +1504,7 @@ var ticketPriorities = ["low", "normal", "high", "urgent"];
 var ticketStatuses = ["backlog", "ready", "in_progress", "blocked", "review", "done", "abandoned"];
 var defaultLeaseTtlSeconds = 5 * 60 * 60;
 var defaultCliApiBaseUrl = "https://cadenceapi.deploy.lvl8studios.com";
+var defaultCliWebBaseUrl = "https://cadence.deploy.lvl8studios.com";
 
 class CliError extends Error {
   code;
@@ -1534,6 +1545,7 @@ var knownCommandPaths = [
   ["tickets", "get"],
   ["events", "list"],
   ["work", "overview"],
+  ["projects", "list"],
   ["init"],
   ["status"],
   ["help"]
@@ -1724,8 +1736,44 @@ function getCredentialStore(options) {
 async function readPromptText(options, message) {
   return options.readText ? options.readText(message) : promptText(message);
 }
-async function readPromptSecret(options, message) {
-  return options.readSecret ? options.readSecret(message) : promptSecret(message);
+function isInteractive(options) {
+  return options.isInteractive ?? Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+function getCliWebBaseUrl(config, parsed, options) {
+  return parsed.options["web-base-url"] ?? options.env?.CADENCE_WEB_BASE_URL ?? process.env.CADENCE_WEB_BASE_URL ?? deriveWebBaseUrl(config.server);
+}
+function deriveWebBaseUrl(server) {
+  try {
+    const url = new URL(server);
+    if ((url.hostname === "localhost" || url.hostname === "127.0.0.1") && url.port === "3000") {
+      url.port = "3001";
+      return url.toString().replace(/\/$/, "");
+    }
+  } catch {
+    return defaultCliWebBaseUrl;
+  }
+  return defaultCliWebBaseUrl;
+}
+async function openBrowser(url, options) {
+  if (options.openBrowser) {
+    await options.openBrowser(url);
+    return;
+  }
+  if (process.platform === "darwin") {
+    const result = spawnSync("open", [url]);
+    if (result.status !== 0) {
+      throw new CliError("BROWSER_OPEN_FAILED", "Could not open the browser for Cadence login.", {
+        loginUrl: url
+      });
+    }
+  }
+}
+async function sleep2(milliseconds, options) {
+  if (options.sleep) {
+    await options.sleep(milliseconds);
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function encodeCredential(credential) {
   return JSON.stringify(credential);
@@ -1773,19 +1821,6 @@ async function promptText(message) {
     readline.close();
   }
 }
-async function promptSecret(message) {
-  if (!process.stdin.isTTY || !process.stderr.isTTY) {
-    throw new CliError("AUTH_INTERACTIVE_REQUIRED", "Interactive auth requires a TTY.");
-  }
-  spawnSync("stty", ["-echo"], { stdio: ["inherit", "ignore", "ignore"] });
-  try {
-    return await promptText(message);
-  } finally {
-    spawnSync("stty", ["echo"], { stdio: ["inherit", "ignore", "ignore"] });
-    process.stderr.write(`
-`);
-  }
-}
 function successEnvelope(data, meta) {
   return {
     success: true,
@@ -1816,11 +1851,12 @@ function helpText() {
     "Cadence CLI",
     "",
     "Usage:",
-    "  cadence init --project <project-id> [--json]",
+    "  cadence init [--project <project-id|org/project>] [--json]",
     "  cadence auth login [--json]",
     "  cadence auth status [--json]",
     "  cadence auth logout [--json]",
     "  cadence status [--project <project-id>] [--json]",
+    "  cadence projects list [--json]",
     "  cadence work overview [--project <project-id>] [--json]",
     "  cadence tickets get <ticket-id> [--project <project-id>] [--json]",
     "  cadence tickets list [--project <project-id>] [--status <status>] [--json]",
@@ -1841,11 +1877,11 @@ function helpText() {
     "  cadence events list [--project <project-id>] [--ticket <ticket-id>] [--changeset <changeset-id>] [--session <session-id>] [--json]",
     "",
     "Global flags:",
-    "  --project <id>       Cadence project ID",
+    "  --project <id>       Cadence project ID or org/project slug",
     "  --json               Print stable JSON envelope",
     "",
     "Auth options:",
-    "  --email <email>       Email for auth login"
+    "  --web-base-url <url> Browser login base URL"
   ].join(`
 `);
 }
@@ -1973,25 +2009,28 @@ async function runStatus(parsed, options) {
 async function runInit(parsed, options) {
   const cwd = options.cwd ?? process.cwd();
   const repoConfigPath = join(cwd, ".cadence", "config.json");
-  const projectId = parsed.flags.project;
-  if (!projectId) {
-    throw new CliError("CLI_USAGE", "init requires --project.");
-  }
+  const config = await resolveCliConfig(parsed.flags, {
+    ...options,
+    cwd
+  });
+  const client = await createClient(config, options);
+  const project = await selectProject(parsed, client, options);
+  const projectId = project.id;
   const updates = {
     projectId,
     ...parsed.flags.server ? { server: parsed.flags.server } : {}
   };
   await mergeConfigFile(repoConfigPath, updates);
-  const config = await resolveCliConfig(parsed.flags, {
-    ...options,
-    cwd
-  });
   const data = {
     repoConfigPath,
     projectId,
+    project,
     ...parsed.flags.server ? { server: parsed.flags.server } : {}
   };
-  const meta = commandMeta(parsed, config);
+  const meta = commandMeta(parsed, {
+    ...config,
+    projectId
+  });
   if (parsed.flags.json) {
     return {
       stdout: formatJson(successEnvelope(data, meta)),
@@ -2006,6 +2045,69 @@ async function runInit(parsed, options) {
     exitCode: 0
   };
 }
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+async function resolveProjectReference(projectReference, client) {
+  if (isUuid(projectReference)) {
+    return {
+      id: projectReference,
+      orgSlug: null,
+      projectSlug: null,
+      name: null
+    };
+  }
+  const [orgSlug, projectSlug, extra] = projectReference.split("/");
+  if (!orgSlug || !projectSlug || extra) {
+    throw new CliError("CLI_USAGE", "--project must be a project ID or org/project slug.");
+  }
+  return await client.projects.resolve({
+    orgSlug,
+    projectSlug
+  });
+}
+function formatProjectChoice(project, index) {
+  const slug = project.orgSlug && project.projectSlug ? `${project.orgSlug}/${project.projectSlug}` : project.id;
+  const name = project.name ? ` ${project.name}` : "";
+  return `${index + 1}. ${slug}${name}`;
+}
+async function selectProject(parsed, client, options) {
+  if (parsed.flags.project) {
+    return await resolveProjectReference(parsed.flags.project, client);
+  }
+  const projects = await client.projects.list();
+  if (projects.length === 1) {
+    return projects[0];
+  }
+  if (parsed.flags.json || !isInteractive(options)) {
+    throw new CliError("PROJECT_REQUIRED", "Choose a Cadence project with --project.", {
+      projects
+    });
+  }
+  if (projects.length === 0) {
+    throw new CliError("PROJECT_REQUIRED", "No accessible Cadence projects were found.");
+  }
+  const message = [
+    "Choose a Cadence project:",
+    ...projects.map(formatProjectChoice),
+    "",
+    "Project number, ID, or org/project: "
+  ].join(`
+`);
+  const answer = (await readPromptText(options, message)).trim();
+  const selectedIndex = Number(answer);
+  const selected = Number.isInteger(selectedIndex) && selectedIndex > 0 ? projects[selectedIndex - 1] : undefined;
+  if (selected) {
+    return selected;
+  }
+  const matching = projects.find((project) => project.id === answer || `${project.orgSlug}/${project.projectSlug}` === answer);
+  if (!matching) {
+    throw new CliError("PROJECT_REQUIRED", "Selected project was not in the accessible project list.", {
+      projects
+    });
+  }
+  return matching;
+}
 async function runAuthCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const store = getCredentialStore(options);
@@ -2014,18 +2116,43 @@ async function runAuthCommand(parsed, options) {
   switch (parsed.command.name) {
     case "auth.login":
       {
-        await requireCredentialStore(store);
         const client = await createClient(config, options);
-        const credential = await client.auth.login({
-          email: parsed.options.email ?? await readPromptText(options, "Email: "),
-          password: await readPromptSecret(options, "Password: ")
+        const challenge = await client.auth.cli.start({
+          loginBaseUrl: getCliWebBaseUrl(config, parsed, options)
+        });
+        if (parsed.flags.json || !isInteractive(options)) {
+          throw new CliError("HUMAN_AUTH_REQUIRED", "Cadence login must be completed by a human in the browser.", {
+            loginUrl: challenge.loginUrl,
+            deviceCode: challenge.deviceCode,
+            expiresAt: challenge.expiresAt
+          });
+        }
+        await requireCredentialStore(store);
+        await openBrowser(challenge.loginUrl, options);
+        let poll = await client.auth.cli.poll({
+          deviceId: challenge.deviceId,
+          deviceCode: challenge.deviceCode
         });
-        await store.setCredential(config.server, encodeCredential(credential));
+        while (poll.status === "pending") {
+          await sleep2(poll.pollIntervalSeconds * 1000, options);
+          poll = await client.auth.cli.poll({
+            deviceId: challenge.deviceId,
+            deviceCode: challenge.deviceCode
+          });
+        }
+        if (poll.status === "expired") {
+          throw new CliError("AUTH_LOGIN_EXPIRED", "Cadence browser login expired.");
+        }
+        if (poll.status === "denied") {
+          throw new CliError("AUTH_LOGIN_DENIED", "Cadence browser login was denied.");
+        }
+        await store.setCredential(config.server, encodeCredential(poll.credential));
         await mergeConfigFile(config.globalConfigPath, { server: config.server });
         data = {
           server: config.server,
           credentialStored: true,
-          globalConfigPath: config.globalConfigPath
+          globalConfigPath: config.globalConfigPath,
+          loginUrl: challenge.loginUrl
         };
       }
       break;
@@ -2153,6 +2280,32 @@ async function runReadCommand(parsed, options) {
     exitCode: 0
   };
 }
+async function runProjectCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const client = await createClient(config, options);
+  const meta = commandMeta(parsed, config);
+  let data;
+  switch (parsed.command.name) {
+    case "projects.list":
+      data = await client.projects.list();
+      break;
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
 async function runIntakeCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const projectId = requireProjectId(config);
@@ -2376,6 +2529,9 @@ async function runCli(argv, options = {}) {
     if (parsed.command.name === "events.list" || parsed.command.name === "work.overview" || parsed.command.name === "tickets.get" || parsed.command.name === "tickets.list" || parsed.command.name === "sessions.current" || parsed.command.name === "changesets.get" || parsed.command.name === "changesets.list") {
       return await runReadCommand(parsed, options);
     }
+    if (parsed.command.name === "projects.list") {
+      return await runProjectCommand(parsed, options);
+    }
     if (parsed.command.name === "intake" || parsed.command.name === "intake.dismiss" || parsed.command.name === "tickets.attach" || parsed.command.name === "tickets.create" || parsed.command.name === "tickets.update" || parsed.command.name === "tickets.claim" || parsed.command.name === "tickets.release" || parsed.command.name === "tickets.complete" || parsed.command.name === "sessions.start" || parsed.command.name === "sessions.end" || parsed.command.name === "changesets.create") {
       return await runIntakeCommand(parsed, options);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycadence/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "bin": {