@rehpic/vcli 0.1.0-beta.10.1

package/dist/index.js

@@ -0,0 +1,2060 @@
+#!/usr/bin/env node
+
+// ../../src/cli/index.ts
+import { readFile as readFile2 } from "fs/promises";
+import { extname } from "path";
+import { config as loadEnv } from "dotenv";
+import { Command } from "commander";
+import { makeFunctionReference } from "convex/server";
+
+// ../../convex/_generated/api.js
+import { anyApi, componentsGeneric } from "convex/server";
+var api = anyApi;
+var components = componentsGeneric();
+
+// ../../src/cli/auth.ts
+import { isCancel, password as passwordPrompt, text } from "@clack/prompts";
+function buildUrl(appUrl, pathname) {
+  return new URL(pathname, appUrl).toString();
+}
+function cookieHeader(cookies) {
+  return Object.entries(cookies).map(([name, value]) => `${name}=${value}`).join("; ");
+}
+function splitSetCookieHeader(value) {
+  return value.split(/,(?=[^;,]+=)/g);
+}
+function applySetCookieHeaders(session, response) {
+  const nextCookies = { ...session.cookies };
+  const rawSetCookies = response.headers.getSetCookie?.() ?? (response.headers.get("set-cookie") ? splitSetCookieHeader(response.headers.get("set-cookie")) : []);
+  for (const rawCookie of rawSetCookies) {
+    const [cookiePart, ...attributeParts] = rawCookie.split(";");
+    const separatorIndex = cookiePart.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const name = cookiePart.slice(0, separatorIndex).trim();
+    const value = cookiePart.slice(separatorIndex + 1).trim();
+    const attributes = attributeParts.map((part) => part.trim().toLowerCase());
+    const maxAge = attributes.find((part) => part.startsWith("max-age="));
+    const expires = attributes.find((part) => part.startsWith("expires="));
+    const expired = value.length === 0 || maxAge === "max-age=0" || (expires ? Number.isFinite(Date.parse(expires.slice(8))) && Date.parse(expires.slice(8)) <= Date.now() : false);
+    if (expired) {
+      delete nextCookies[name];
+    } else {
+      nextCookies[name] = value;
+    }
+  }
+  return {
+    ...session,
+    cookies: nextCookies
+  };
+}
+async function authRequest(session, appUrl, pathname, init = {}) {
+  const headers = new Headers(init.headers);
+  const origin = new URL(appUrl).origin;
+  if (Object.keys(session.cookies).length > 0) {
+    headers.set("cookie", cookieHeader(session.cookies));
+  }
+  if (!headers.has("origin")) {
+    headers.set("origin", origin);
+  }
+  if (!headers.has("referer")) {
+    headers.set("referer", `${origin}/`);
+  }
+  if (init.body && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  const response = await fetch(buildUrl(appUrl, pathname), {
+    ...init,
+    headers,
+    redirect: "manual"
+  });
+  const nextSession = applySetCookieHeaders(session, response);
+  return { response, session: nextSession };
+}
+async function parseError(response) {
+  try {
+    const data = await response.json();
+    return data.error?.message ?? `Request failed with HTTP ${response.status}`;
+  } catch {
+    return `Request failed with HTTP ${response.status}`;
+  }
+}
+async function loginWithPassword(session, appUrl, identifier, password) {
+  const pathname = identifier.includes("@") ? "/api/auth/sign-in/email" : "/api/auth/sign-in/username";
+  const body = identifier.includes("@") ? { email: identifier, password } : { username: identifier, password };
+  const { response, session: nextSession } = await authRequest(
+    session,
+    appUrl,
+    pathname,
+    {
+      method: "POST",
+      body: JSON.stringify(body)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+  return nextSession;
+}
+async function signUpWithEmail(session, appUrl, email, username, password) {
+  const { response, session: nextSession } = await authRequest(
+    session,
+    appUrl,
+    "/api/auth/sign-up/email",
+    {
+      method: "POST",
+      body: JSON.stringify({
+        email,
+        password,
+        name: username,
+        username
+      })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+  return nextSession;
+}
+async function logout(session, appUrl) {
+  const { response } = await authRequest(
+    session,
+    appUrl,
+    "/api/auth/sign-out",
+    {
+      method: "POST",
+      body: JSON.stringify({})
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+}
+async function fetchAuthSession(session, appUrl) {
+  const { response, session: nextSession } = await authRequest(
+    session,
+    appUrl,
+    "/api/auth/get-session",
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+  const data = await response.json();
+  return {
+    session: nextSession,
+    user: data.user ?? null
+  };
+}
+async function fetchConvexToken(session, appUrl) {
+  const { response, session: nextSession } = await authRequest(
+    session,
+    appUrl,
+    "/api/auth/convex/token",
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    throw new Error(await parseError(response));
+  }
+  const data = await response.json();
+  if (!data.token) {
+    throw new Error("Missing Convex token");
+  }
+  return {
+    session: nextSession,
+    token: data.token
+  };
+}
+async function prompt(question) {
+  const value = await text({
+    message: question.replace(/:\s*$/, "")
+  });
+  if (isCancel(value)) {
+    throw new Error("Canceled");
+  }
+  return String(value).trim();
+}
+async function promptSecret(question) {
+  const value = await passwordPrompt({
+    message: question.replace(/:\s*$/, ""),
+    mask: "*"
+  });
+  if (isCancel(value)) {
+    throw new Error("Canceled");
+  }
+  return String(value);
+}
+
+// ../../src/cli/convex.ts
+import { ConvexHttpClient } from "convex/browser";
+async function createConvexClient(session, appUrl, convexUrl) {
+  const { token } = await fetchConvexToken(session, appUrl);
+  const client = new ConvexHttpClient(convexUrl);
+  client.setAuth(token);
+  return client;
+}
+async function runQuery(client, ref, ...args) {
+  return await client.query(ref, ...args);
+}
+async function runMutation(client, ref, ...args) {
+  return await client.mutation(ref, ...args);
+}
+async function runAction(client, ref, ...args) {
+  return await client.action(ref, ...args);
+}
+
+// ../../src/cli/output.ts
+function simplify(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [];
+    }
+    if (value.every((item) => typeof item !== "object" || item === null)) {
+      return value.join(", ");
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function printOutput(data, json = false) {
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log("No results.");
+      return;
+    }
+    if (data.every((item) => typeof item === "object" && item !== null)) {
+      console.table(
+        data.map(
+          (item) => Object.fromEntries(
+            Object.entries(item).map(([key, value]) => [key, simplify(value)])
+          )
+        )
+      );
+      return;
+    }
+  }
+  if (typeof data === "object" && data !== null) {
+    console.dir(data, { depth: null, colors: true });
+    return;
+  }
+  console.log(String(data));
+}
+
+// ../../src/cli/session.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+var SESSION_ROOT = path.join(homedir(), ".vector");
+function getSessionPath(profile = "default") {
+  return path.join(SESSION_ROOT, `cli-${profile}.json`);
+}
+async function readSession(profile = "default") {
+  try {
+    const raw = await readFile(getSessionPath(profile), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      version: 1,
+      cookies: {},
+      ...parsed
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeSession(session, profile = "default") {
+  await mkdir(SESSION_ROOT, { recursive: true });
+  await writeFile(
+    getSessionPath(profile),
+    `${JSON.stringify(session, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function clearSession(profile = "default") {
+  await rm(getSessionPath(profile), { force: true });
+}
+function createEmptySession() {
+  return {
+    version: 1,
+    cookies: {}
+  };
+}
+
+// ../../src/cli/index.ts
+loadEnv({ path: ".env.local", override: false });
+loadEnv({ path: ".env", override: false });
+var cliApi = {
+  listWorkspaceReferenceData: makeFunctionReference(
+    "cli:listWorkspaceReferenceData"
+  ),
+  searchIcons: makeFunctionReference("cli:searchIcons"),
+  listDocuments: makeFunctionReference("cli:listDocuments"),
+  getDocument: makeFunctionReference("cli:getDocument"),
+  createDocument: makeFunctionReference("cli:createDocument"),
+  updateDocument: makeFunctionReference("cli:updateDocument"),
+  deleteDocument: makeFunctionReference("cli:deleteDocument"),
+  moveDocumentToFolder: makeFunctionReference(
+    "cli:moveDocumentToFolder"
+  ),
+  listIssues: makeFunctionReference("cli:listIssues"),
+  getIssue: makeFunctionReference("cli:getIssue"),
+  createIssue: makeFunctionReference("cli:createIssue"),
+  updateIssue: makeFunctionReference("cli:updateIssue"),
+  deleteIssue: makeFunctionReference("cli:deleteIssue"),
+  assignIssue: makeFunctionReference("cli:assignIssue"),
+  unassignIssue: makeFunctionReference("cli:unassignIssue"),
+  listProjects: makeFunctionReference("cli:listProjects"),
+  getProject: makeFunctionReference("cli:getProject"),
+  createProject: makeFunctionReference("cli:createProject"),
+  updateProject: makeFunctionReference("cli:updateProject"),
+  deleteProject: makeFunctionReference("cli:deleteProject"),
+  addProjectMember: makeFunctionReference("cli:addProjectMember"),
+  removeProjectMember: makeFunctionReference(
+    "cli:removeProjectMember"
+  ),
+  changeProjectLead: makeFunctionReference("cli:changeProjectLead"),
+  listTeams: makeFunctionReference("cli:listTeams"),
+  getTeam: makeFunctionReference("cli:getTeam"),
+  createTeam: makeFunctionReference("cli:createTeam"),
+  updateTeam: makeFunctionReference("cli:updateTeam"),
+  deleteTeam: makeFunctionReference("cli:deleteTeam"),
+  addTeamMember: makeFunctionReference("cli:addTeamMember"),
+  removeTeamMember: makeFunctionReference("cli:removeTeamMember"),
+  changeTeamLead: makeFunctionReference("cli:changeTeamLead"),
+  listFolders: makeFunctionReference("cli:listFolders"),
+  createFolder: makeFunctionReference("cli:createFolder"),
+  updateFolder: makeFunctionReference("cli:updateFolder"),
+  deleteFolder: makeFunctionReference("cli:deleteFolder")
+};
+var rolesApi = api.roles.index;
+var ISSUE_STATE_TYPES = [
+  "backlog",
+  "todo",
+  "in_progress",
+  "done",
+  "canceled"
+];
+var PROJECT_STATUS_TYPES = [
+  "backlog",
+  "planned",
+  "in_progress",
+  "completed",
+  "canceled"
+];
+var NOTIFICATION_CATEGORIES = [
+  "invites",
+  "assignments",
+  "mentions",
+  "comments"
+];
+function requiredString(value, label) {
+  if (!value?.trim()) {
+    throw new Error(`${label} is required`);
+  }
+  return value.trim();
+}
+function optionalNumber(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`${label} must be a valid number`);
+  }
+  return parsed;
+}
+function requiredNumber(value, label) {
+  const parsed = optionalNumber(value, label);
+  if (parsed === void 0) {
+    throw new Error(`${label} is required`);
+  }
+  return parsed;
+}
+function parseBoolean(value, label) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  throw new Error(`${label} must be "true" or "false"`);
+}
+function parseList(value) {
+  if (!value) return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function buildPaginationOptions(limit, cursor) {
+  return {
+    cursor: cursor ?? null,
+    numItems: optionalNumber(limit, "limit") ?? 20
+  };
+}
+function normalizeMatch(value) {
+  return value?.trim().toLowerCase();
+}
+async function fetchConvexUrl(appUrl) {
+  try {
+    const url = new URL("/api/config", appUrl).toString();
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.convexUrl) {
+      return data.convexUrl;
+    }
+  } catch {
+  }
+  return "http://127.0.0.1:3210";
+}
+async function getRuntime(command) {
+  const options = command.optsWithGlobals();
+  const profile = options.profile ?? "default";
+  const session = await readSession(profile);
+  const appUrlSource = options.appUrl ?? session?.appUrl ?? process.env.NEXT_PUBLIC_APP_URL;
+  const appUrl = requiredString(appUrlSource, "app URL");
+  let convexUrl = options.convexUrl ?? session?.convexUrl ?? process.env.NEXT_PUBLIC_CONVEX_URL ?? process.env.CONVEX_URL;
+  if (!convexUrl) {
+    convexUrl = await fetchConvexUrl(appUrl);
+  }
+  return {
+    appUrl,
+    convexUrl,
+    json: Boolean(options.json),
+    org: options.org ?? session?.activeOrgSlug,
+    profile,
+    session
+  };
+}
+function requireSession(runtime) {
+  if (!runtime.session || Object.keys(runtime.session.cookies).length === 0) {
+    throw new Error("Not logged in. Run `vcli auth login` first.");
+  }
+  return runtime.session;
+}
+function requireOrg(runtime, explicit) {
+  const orgSlug = explicit ?? runtime.org;
+  if (!orgSlug) {
+    throw new Error(
+      "Organization slug is required. Pass `--org <slug>` or run `vcli org use <slug>`."
+    );
+  }
+  return orgSlug;
+}
+async function getClient(command) {
+  const runtime = await getRuntime(command);
+  const session = requireSession(runtime);
+  const client = await createConvexClient(
+    session,
+    runtime.appUrl,
+    runtime.convexUrl
+  );
+  return { client, runtime, session };
+}
+async function resolveMemberId(client, orgSlug, ref) {
+  const members = await runQuery(
+    client,
+    api.organizations.queries.listMembers,
+    {
+      orgSlug
+    }
+  );
+  const needle = normalizeMatch(ref);
+  const matches = members.filter((member) => {
+    const user = member.user;
+    if (!user) return false;
+    return normalizeMatch(String(user._id)) === needle || normalizeMatch(user.email) === needle || normalizeMatch(user.name) === needle || normalizeMatch(user.username) === needle;
+  });
+  if (matches.length === 0) {
+    throw new Error(`No member matched "${ref}"`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Multiple members matched "${ref}"`);
+  }
+  return matches[0].user._id;
+}
+async function resolveRoleId(client, orgSlug, ref) {
+  const roles = await runQuery(client, rolesApi.list, { orgSlug });
+  const needle = normalizeMatch(ref);
+  const matches = roles.filter((role) => {
+    const candidate = role;
+    return normalizeMatch(String(candidate._id)) === needle || normalizeMatch(candidate.name) === needle || normalizeMatch(candidate.key) === needle;
+  });
+  if (matches.length === 0) {
+    throw new Error(`No role matched "${ref}"`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Multiple roles matched "${ref}"`);
+  }
+  return matches[0]._id;
+}
+function parsePermissions(value) {
+  return value.split(",").map((permission) => permission.trim()).filter(Boolean);
+}
+function nullableOption(value, clear = false) {
+  if (clear) return null;
+  return value;
+}
+function mimeTypeForFile(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function uploadFile(uploadUrl, filePath) {
+  const body = await readFile2(filePath);
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": mimeTypeForFile(filePath)
+    },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`Upload failed with HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  if (!data.storageId) {
+    throw new Error("Upload response did not include a storageId");
+  }
+  return data.storageId;
+}
+async function resolveTeamId(client, orgSlug, teamKey) {
+  if (!teamKey) {
+    return void 0;
+  }
+  const team = await runAction(client, cliApi.getTeam, { orgSlug, teamKey });
+  return team.id;
+}
+async function resolveProjectId(client, orgSlug, projectKey) {
+  if (!projectKey) {
+    return void 0;
+  }
+  const project = await runAction(client, cliApi.getProject, {
+    orgSlug,
+    projectKey
+  });
+  return project.id;
+}
+async function resolveIssueId(client, orgSlug, issueKey) {
+  const issue = await runAction(client, cliApi.getIssue, { orgSlug, issueKey });
+  return issue.id;
+}
+async function resolveDocumentId(client, orgSlug, documentId) {
+  const document = await runAction(client, cliApi.getDocument, {
+    orgSlug,
+    documentId
+  });
+  return document.id;
+}
+async function resolveIssueStateId(client, orgSlug, ref) {
+  const states = await runQuery(
+    client,
+    api.organizations.queries.listIssueStates,
+    {
+      orgSlug
+    }
+  );
+  const needle = normalizeMatch(ref);
+  const match = states.find((state) => {
+    return normalizeMatch(String(state._id)) === needle || normalizeMatch(state.name) === needle || normalizeMatch(state.type) === needle;
+  });
+  if (!match) {
+    throw new Error(`No issue state matched "${ref}"`);
+  }
+  return match._id;
+}
+async function resolveIssuePriorityId(client, orgSlug, ref) {
+  const priorities = await runQuery(
+    client,
+    api.organizations.queries.listIssuePriorities,
+    { orgSlug }
+  );
+  const needle = normalizeMatch(ref);
+  const match = priorities.find((priority) => {
+    return normalizeMatch(String(priority._id)) === needle || normalizeMatch(priority.name) === needle;
+  });
+  if (!match) {
+    throw new Error(`No issue priority matched "${ref}"`);
+  }
+  return match._id;
+}
+async function resolveProjectStatusId(client, orgSlug, ref) {
+  const statuses = await runQuery(
+    client,
+    api.organizations.queries.listProjectStatuses,
+    { orgSlug }
+  );
+  const needle = normalizeMatch(ref);
+  const match = statuses.find((status) => {
+    return normalizeMatch(String(status._id)) === needle || normalizeMatch(status.name) === needle || normalizeMatch(status.type) === needle;
+  });
+  if (!match) {
+    throw new Error(`No project status matched "${ref}"`);
+  }
+  return match._id;
+}
+async function parseEstimatedTimes(client, orgSlug, value) {
+  const entries = parseList(value);
+  const estimatedTimes = {};
+  for (const entry of entries) {
+    const separatorIndex = entry.indexOf("=");
+    if (separatorIndex <= 0) {
+      throw new Error(
+        'estimated times must use the format "state=hours,state=hours"'
+      );
+    }
+    const stateRef = entry.slice(0, separatorIndex).trim();
+    const hours = Number(entry.slice(separatorIndex + 1).trim());
+    if (!Number.isFinite(hours)) {
+      throw new Error(`Invalid estimate for "${stateRef}"`);
+    }
+    const stateId = await resolveIssueStateId(client, orgSlug, stateRef);
+    estimatedTimes[String(stateId)] = hours;
+  }
+  return estimatedTimes;
+}
+var program = new Command();
+program.name("vcli").description("Vector CLI").showHelpAfterError().option(
+  "--app-url <url>",
+  "Vector app URL. Required unless saved in the profile or NEXT_PUBLIC_APP_URL is set."
+).option("--convex-url <url>", "Convex deployment URL").option("--org <slug>", "Organization slug override").option("--profile <name>", "CLI profile name", "default").option("--json", "Output JSON");
+var authCommand = program.command("auth").description("Authentication");
+authCommand.command("signup").option("--email <email>", "Email address").option("--username <username>", "Username").option("--password <password>", "Password").action(async (options, command) => {
+  const runtime = await getRuntime(command);
+  const email = requiredString(
+    options.email?.trim() || await prompt("Email: "),
+    "email"
+  ).toLowerCase();
+  const username = requiredString(
+    options.username?.trim() || await prompt("Username: "),
+    "username"
+  );
+  const password = options.password?.trim() || await promptSecret("Password: ");
+  let session = createEmptySession();
+  session.appUrl = runtime.appUrl;
+  session.convexUrl = runtime.convexUrl;
+  session = await signUpWithEmail(
+    session,
+    runtime.appUrl,
+    email,
+    username,
+    password
+  );
+  const authState = await fetchAuthSession(session, runtime.appUrl);
+  session = authState.session;
+  const client = await createConvexClient(
+    session,
+    runtime.appUrl,
+    runtime.convexUrl
+  );
+  const orgs = await runQuery(client, api.users.getOrganizations, {});
+  session.activeOrgSlug = orgs[0]?.slug ?? session.activeOrgSlug;
+  await writeSession(session, runtime.profile);
+  printOutput(
+    {
+      signedUpAs: authState.user?.email ?? authState.user?.username ?? authState.user?.name,
+      activeOrgSlug: session.activeOrgSlug ?? null
+    },
+    runtime.json
+  );
+});
+authCommand.command("login [identifier]").option("--password <password>", "Password").action(async (identifier, options, command) => {
+  const runtime = await getRuntime(command);
+  const loginId = identifier?.trim() || await prompt("Email or username: ");
+  const password = options.password?.trim() || await promptSecret("Password: ");
+  let session = createEmptySession();
+  session.appUrl = runtime.appUrl;
+  session.convexUrl = runtime.convexUrl;
+  session = await loginWithPassword(
+    session,
+    runtime.appUrl,
+    loginId,
+    password
+  );
+  const authState = await fetchAuthSession(session, runtime.appUrl);
+  session = authState.session;
+  const client = await createConvexClient(
+    session,
+    runtime.appUrl,
+    runtime.convexUrl
+  );
+  const orgs = await runQuery(client, api.users.getOrganizations, {});
+  session.activeOrgSlug = orgs[0]?.slug ?? session.activeOrgSlug;
+  await writeSession(session, runtime.profile);
+  printOutput(
+    {
+      loggedInAs: authState.user?.email ?? authState.user?.username ?? authState.user?.name,
+      activeOrgSlug: session.activeOrgSlug ?? null
+    },
+    runtime.json
+  );
+});
+authCommand.command("logout").action(async (_options, command) => {
+  const runtime = await getRuntime(command);
+  const session = requireSession(runtime);
+  await logout(session, runtime.appUrl);
+  await clearSession(runtime.profile);
+  printOutput({ success: true }, runtime.json);
+});
+authCommand.command("whoami").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const [user, orgs] = await Promise.all([
+    runQuery(client, api.users.getCurrentUser, {}),
+    runQuery(client, api.users.getOrganizations, {})
+  ]);
+  printOutput(
+    {
+      user,
+      organizations: orgs,
+      activeOrgSlug: runtime.org ?? null
+    },
+    runtime.json
+  );
+});
+var orgCommand = program.command("org").description("Organizations");
+orgCommand.command("list").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgs = await runQuery(client, api.users.getOrganizations, {});
+  printOutput(orgs, runtime.json);
+});
+orgCommand.command("current").action(async (_options, command) => {
+  const runtime = await getRuntime(command);
+  printOutput({ activeOrgSlug: runtime.org ?? null }, runtime.json);
+});
+orgCommand.command("use <slug>").action(async (slug, _options, command) => {
+  const runtime = await getRuntime(command);
+  const session = requireSession(runtime);
+  session.activeOrgSlug = slug;
+  session.appUrl = runtime.appUrl;
+  session.convexUrl = runtime.convexUrl;
+  await writeSession(session, runtime.profile);
+  printOutput({ activeOrgSlug: slug }, runtime.json);
+});
+orgCommand.command("create").requiredOption("--name <name>").requiredOption("--slug <slug>").action(async (options, command) => {
+  const { client, runtime, session } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.create,
+    {
+      data: {
+        name: options.name,
+        slug: options.slug
+      }
+    }
+  );
+  if (session) {
+    session.activeOrgSlug = options.slug;
+    session.appUrl = runtime.appUrl;
+    session.convexUrl = runtime.convexUrl;
+    await writeSession(session, runtime.profile);
+  }
+  printOutput(result, runtime.json);
+});
+orgCommand.command("update [slug]").option("--name <name>").option("--new-slug <slug>").action(async (slug, options, command) => {
+  const { client, runtime, session } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.update,
+    {
+      orgSlug,
+      data: {
+        ...options.name ? { name: options.name } : {},
+        ...options.newSlug ? { slug: options.newSlug } : {}
+      }
+    }
+  );
+  if (session && options.newSlug && session.activeOrgSlug === orgSlug) {
+    session.activeOrgSlug = options.newSlug;
+    await writeSession(session, runtime.profile);
+  }
+  printOutput(result, runtime.json);
+});
+orgCommand.command("stats [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runQuery(
+    client,
+    api.organizations.queries.getOrganizationStats,
+    { orgSlug }
+  );
+  printOutput(result, runtime.json);
+});
+orgCommand.command("logo [slug]").option("--file <path>").option("--remove").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  if (options.remove) {
+    throw new Error(
+      "Organization logo removal is not exposed by the current backend API."
+    );
+  }
+  const filePath = requiredString(options.file, "file");
+  const uploadUrl = await runMutation(
+    client,
+    api.organizations.mutations.generateLogoUploadUrl,
+    { orgSlug }
+  );
+  const storageId = await uploadFile(uploadUrl, filePath);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.updateLogoWithStorageId,
+    {
+      orgSlug,
+      storageId
+    }
+  );
+  printOutput(
+    { ...result ?? { success: true }, storageId, orgSlug },
+    runtime.json
+  );
+});
+orgCommand.command("members [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const members = await runQuery(
+    client,
+    api.organizations.queries.listMembersWithRoles,
+    {
+      orgSlug
+    }
+  );
+  printOutput(members, runtime.json);
+});
+orgCommand.command("invites [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const invites = await runQuery(
+    client,
+    api.organizations.queries.listInvites,
+    {
+      orgSlug
+    }
+  );
+  printOutput(invites, runtime.json);
+});
+orgCommand.command("invite [slug]").requiredOption("--email <email>").option("--role <role>", "member or admin", "member").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.invite,
+    {
+      orgSlug,
+      email: options.email,
+      role: options.role
+    }
+  );
+  printOutput(result, runtime.json);
+});
+orgCommand.command("member-role <member>").requiredOption("--role <role>", "member or admin").action(async (member, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const userId = await resolveMemberId(client, orgSlug, member);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.updateMemberRole,
+    {
+      orgSlug,
+      userId,
+      role: options.role
+    }
+  );
+  printOutput(result, runtime.json);
+});
+orgCommand.command("remove-member <member>").action(async (member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const userId = await resolveMemberId(client, orgSlug, member);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.removeMember,
+    {
+      orgSlug,
+      userId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+orgCommand.command("revoke-invite <inviteId>").action(async (inviteId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.revokeInvite,
+    {
+      inviteId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+var roleCommand = program.command("role").description("Organization roles");
+roleCommand.command("list [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const roles = await runQuery(client, rolesApi.list, { orgSlug });
+  printOutput(roles, runtime.json);
+});
+roleCommand.command("get <role>").action(async (role, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const roleId = await resolveRoleId(client, orgSlug, role);
+  const [summary, permissions] = await Promise.all([
+    runQuery(client, rolesApi.get, { orgSlug, roleId }),
+    runQuery(client, rolesApi.getPermissions, { roleId })
+  ]);
+  printOutput({ summary, permissions }, runtime.json);
+});
+roleCommand.command("create").requiredOption("--name <name>").requiredOption("--permissions <permissions>", "Comma-separated permissions").option("--description <description>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runMutation(client, rolesApi.create, {
+    orgSlug,
+    name: options.name,
+    description: options.description,
+    permissions: parsePermissions(options.permissions)
+  });
+  printOutput({ roleId: result }, runtime.json);
+});
+roleCommand.command("update <role>").requiredOption("--name <name>").requiredOption("--permissions <permissions>", "Comma-separated permissions").option("--description <description>").action(async (role, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const roleId = await resolveRoleId(client, orgSlug, role);
+  const result = await runMutation(client, rolesApi.update, {
+    orgSlug,
+    roleId,
+    name: options.name,
+    description: options.description,
+    permissions: parsePermissions(options.permissions)
+  });
+  printOutput(result ?? { success: true }, runtime.json);
+});
+roleCommand.command("assign <role> <member>").action(async (role, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const [roleId, userId] = await Promise.all([
+    resolveRoleId(client, orgSlug, role),
+    resolveMemberId(client, orgSlug, member)
+  ]);
+  const result = await runMutation(client, rolesApi.assign, {
+    orgSlug,
+    roleId,
+    userId
+  });
+  printOutput({ assignmentId: result }, runtime.json);
+});
+roleCommand.command("unassign <role> <member>").action(async (role, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const [roleId, userId] = await Promise.all([
+    resolveRoleId(client, orgSlug, role),
+    resolveMemberId(client, orgSlug, member)
+  ]);
+  const result = await runMutation(client, rolesApi.removeAssignment, {
+    orgSlug,
+    roleId,
+    userId
+  });
+  printOutput(result ?? { success: true }, runtime.json);
+});
+var inviteCommand = program.command("invite").description("Invitations");
+inviteCommand.command("list").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const invites = await runQuery(client, api.users.getPendingInvitations, {});
+  printOutput(invites, runtime.json);
+});
+inviteCommand.command("accept <inviteId>").action(async (inviteId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.acceptInvitation,
+    { inviteId }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+inviteCommand.command("decline <inviteId>").action(async (inviteId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.declineInvitation,
+    { inviteId }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+program.command("refdata [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listWorkspaceReferenceData, {
+    orgSlug
+  });
+  printOutput(result, runtime.json);
+});
+program.command("icons <query>").option("--limit <n>").action(async (query, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runAction(client, cliApi.searchIcons, {
+    query,
+    limit: options.limit ? Number(options.limit) : void 0
+  });
+  printOutput(result, runtime.json);
+});
+program.command("search <query>").option("--limit <n>").action(async (query, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runQuery(client, api.search.queries.searchEntities, {
+    orgSlug,
+    query,
+    limit: optionalNumber(options.limit, "limit")
+  });
+  printOutput(result, runtime.json);
+});
+var permissionCommand = program.command("permission").description("Permission checks");
+permissionCommand.command("check <permission>").option("--team <teamKey>").option("--project <projectKey>").action(async (permission, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const [teamId, projectId] = await Promise.all([
+    resolveTeamId(client, orgSlug, options.team),
+    resolveProjectId(client, orgSlug, options.project)
+  ]);
+  const result = await runQuery(client, api.permissions.utils.has, {
+    orgSlug,
+    permission,
+    teamId,
+    projectId
+  });
+  printOutput(
+    { permission, allowed: result, teamId, projectId },
+    runtime.json
+  );
+});
+permissionCommand.command("check-many <permissions>").option("--team <teamKey>").option("--project <projectKey>").action(async (permissions, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const [teamId, projectId] = await Promise.all([
+    resolveTeamId(client, orgSlug, options.team),
+    resolveProjectId(client, orgSlug, options.project)
+  ]);
+  const permissionList = parsePermissions(permissions);
+  const result = await runQuery(client, api.permissions.utils.hasMultiple, {
+    orgSlug,
+    permissions: permissionList,
+    teamId,
+    projectId
+  });
+  printOutput(result, runtime.json);
+});
+var activityCommand = program.command("activity").description("Activity feed");
+activityCommand.command("project <projectKey>").option("--limit <n>").option("--cursor <cursor>").action(async (projectKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const projectId = await resolveProjectId(client, orgSlug, projectKey);
+  const result = await runQuery(
+    client,
+    api.activities.queries.listProjectActivity,
+    {
+      projectId,
+      paginationOpts: buildPaginationOptions(options.limit, options.cursor)
+    }
+  );
+  printOutput(result, runtime.json);
+});
+activityCommand.command("team <teamKey>").option("--limit <n>").option("--cursor <cursor>").action(async (teamKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const teamId = await resolveTeamId(client, orgSlug, teamKey);
+  const result = await runQuery(
+    client,
+    api.activities.queries.listTeamActivity,
+    {
+      teamId,
+      paginationOpts: buildPaginationOptions(options.limit, options.cursor)
+    }
+  );
+  printOutput(result, runtime.json);
+});
+activityCommand.command("issue <issueKey>").option("--limit <n>").option("--cursor <cursor>").action(async (issueKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const issueId = await resolveIssueId(client, orgSlug, issueKey);
+  const result = await runQuery(
+    client,
+    api.activities.queries.listIssueActivity,
+    {
+      issueId,
+      paginationOpts: buildPaginationOptions(options.limit, options.cursor)
+    }
+  );
+  printOutput(result, runtime.json);
+});
+activityCommand.command("document <documentId>").option("--limit <n>").option("--cursor <cursor>").action(async (documentId, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const resolvedDocumentId = await resolveDocumentId(
+    client,
+    orgSlug,
+    documentId
+  );
+  const result = await runQuery(
+    client,
+    api.activities.queries.listDocumentActivity,
+    {
+      documentId: resolvedDocumentId,
+      paginationOpts: buildPaginationOptions(options.limit, options.cursor)
+    }
+  );
+  printOutput(result, runtime.json);
+});
+var notificationCommand = program.command("notification").description("Notifications");
+notificationCommand.command("inbox").option("--filter <filter>", "all or unread").option("--limit <n>").option("--cursor <cursor>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(client, api.notifications.queries.listInbox, {
+    filter: options.filter,
+    paginationOpts: buildPaginationOptions(options.limit, options.cursor)
+  });
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("unread-count").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(
+    client,
+    api.notifications.queries.unreadCount,
+    {}
+  );
+  printOutput({ unreadCount: result }, runtime.json);
+});
+notificationCommand.command("mark-read <recipientId>").action(async (recipientId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.notifications.mutations.markRead,
+    {
+      recipientId
+    }
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("mark-all-read").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.notifications.mutations.markAllRead,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("archive <recipientId>").action(async (recipientId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.notifications.mutations.archive,
+    {
+      recipientId
+    }
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("preferences").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(
+    client,
+    api.notifications.queries.getPreferences,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("set-preference <category>").requiredOption("--in-app <true|false>").requiredOption("--email <true|false>").requiredOption("--push <true|false>").action(async (category, options, command) => {
+  const { client, runtime } = await getClient(command);
+  if (!NOTIFICATION_CATEGORIES.includes(category)) {
+    throw new Error(
+      `category must be one of: ${NOTIFICATION_CATEGORIES.join(", ")}`
+    );
+  }
+  const result = await runMutation(
+    client,
+    api.notifications.mutations.updatePreferences,
+    {
+      category,
+      inAppEnabled: parseBoolean(options.inApp, "in-app"),
+      emailEnabled: parseBoolean(options.email, "email"),
+      pushEnabled: parseBoolean(options.push, "push")
+    }
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("subscriptions").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(
+    client,
+    api.notifications.queries.listPushSubscriptions,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+notificationCommand.command("remove-subscription <subscriptionId>").action(async (subscriptionId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.notifications.mutations.removePushSubscription,
+    { subscriptionId }
+  );
+  printOutput(result, runtime.json);
+});
+var priorityCommand = program.command("priority").description("Issue priorities");
+priorityCommand.command("list [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runQuery(
+    client,
+    api.organizations.queries.listIssuePriorities,
+    { orgSlug }
+  );
+  printOutput(result, runtime.json);
+});
+priorityCommand.command("create").requiredOption("--name <name>").requiredOption("--weight <n>").requiredOption("--color <hex>").option("--icon <icon>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.createIssuePriority,
+    {
+      orgSlug,
+      name: options.name,
+      weight: requiredNumber(options.weight, "weight"),
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result, runtime.json);
+});
+priorityCommand.command("update <priority>").requiredOption("--name <name>").requiredOption("--color <hex>").option("--weight <n>").option("--icon <icon>").action(async (priority, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const priorityId = await resolveIssuePriorityId(client, orgSlug, priority);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.updateIssuePriority,
+    {
+      orgSlug,
+      priorityId,
+      name: options.name,
+      weight: optionalNumber(options.weight, "weight"),
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+priorityCommand.command("delete <priority>").action(async (priority, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const priorityId = await resolveIssuePriorityId(client, orgSlug, priority);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.deleteIssuePriority,
+    {
+      orgSlug,
+      priorityId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+priorityCommand.command("reset [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.resetIssuePriorities,
+    { orgSlug }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+var stateCommand = program.command("state").description("Issue states");
+stateCommand.command("list [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runQuery(
+    client,
+    api.organizations.queries.listIssueStates,
+    {
+      orgSlug
+    }
+  );
+  printOutput(result, runtime.json);
+});
+stateCommand.command("create").requiredOption("--name <name>").requiredOption("--position <n>").requiredOption("--type <type>").requiredOption("--color <hex>").option("--icon <icon>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  if (!ISSUE_STATE_TYPES.includes(options.type)) {
+    throw new Error(`type must be one of: ${ISSUE_STATE_TYPES.join(", ")}`);
+  }
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.createIssueState,
+    {
+      orgSlug,
+      name: options.name,
+      position: requiredNumber(options.position, "position"),
+      type: options.type,
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result, runtime.json);
+});
+stateCommand.command("update <state>").requiredOption("--name <name>").requiredOption("--position <n>").requiredOption("--type <type>").requiredOption("--color <hex>").option("--icon <icon>").action(async (state, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  if (!ISSUE_STATE_TYPES.includes(options.type)) {
+    throw new Error(`type must be one of: ${ISSUE_STATE_TYPES.join(", ")}`);
+  }
+  const stateId = await resolveIssueStateId(client, orgSlug, state);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.updateIssueState,
+    {
+      orgSlug,
+      stateId,
+      name: options.name,
+      position: requiredNumber(options.position, "position"),
+      type: options.type,
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+stateCommand.command("delete <state>").action(async (state, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const stateId = await resolveIssueStateId(client, orgSlug, state);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.deleteIssueState,
+    {
+      orgSlug,
+      stateId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+stateCommand.command("reset [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.resetIssueStates,
+    { orgSlug }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+var statusCommand = program.command("status").description("Project statuses");
+statusCommand.command("list [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runQuery(
+    client,
+    api.organizations.queries.listProjectStatuses,
+    { orgSlug }
+  );
+  printOutput(result, runtime.json);
+});
+statusCommand.command("create").requiredOption("--name <name>").requiredOption("--position <n>").requiredOption("--type <type>").requiredOption("--color <hex>").option("--icon <icon>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  if (!PROJECT_STATUS_TYPES.includes(options.type)) {
+    throw new Error(
+      `type must be one of: ${PROJECT_STATUS_TYPES.join(", ")}`
+    );
+  }
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.createProjectStatus,
+    {
+      orgSlug,
+      name: options.name,
+      position: requiredNumber(options.position, "position"),
+      type: options.type,
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result, runtime.json);
+});
+statusCommand.command("update <status>").requiredOption("--name <name>").requiredOption("--position <n>").requiredOption("--type <type>").requiredOption("--color <hex>").option("--icon <icon>").action(async (status, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  if (!PROJECT_STATUS_TYPES.includes(options.type)) {
+    throw new Error(
+      `type must be one of: ${PROJECT_STATUS_TYPES.join(", ")}`
+    );
+  }
+  const statusId = await resolveProjectStatusId(client, orgSlug, status);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.updateProjectStatus,
+    {
+      orgSlug,
+      statusId,
+      name: options.name,
+      position: requiredNumber(options.position, "position"),
+      type: options.type,
+      color: options.color,
+      icon: options.icon
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+statusCommand.command("delete <status>").action(async (status, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const statusId = await resolveProjectStatusId(client, orgSlug, status);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.deleteProjectStatus,
+    {
+      orgSlug,
+      statusId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+statusCommand.command("reset [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runMutation(
+    client,
+    api.organizations.mutations.resetProjectStatuses,
+    { orgSlug }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+var adminCommand = program.command("admin").description("Platform admin");
+adminCommand.command("branding").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(
+    client,
+    api.platformAdmin.queries.getBranding,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+adminCommand.command("set-branding").option("--name <name>").option("--description <description>").option("--theme-color <hex>").option("--accent-color <hex>").option("--logo <path>").option("--remove-logo").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  let logoStorageId;
+  if (options.logo) {
+    const uploadUrl = await runMutation(
+      client,
+      api.platformAdmin.mutations.generateBrandLogoUploadUrl,
+      {}
+    );
+    logoStorageId = await uploadFile(uploadUrl, options.logo);
+  }
+  const result = await runMutation(
+    client,
+    api.platformAdmin.mutations.updateBranding,
+    {
+      name: options.name,
+      description: options.description,
+      logoStorageId,
+      removeLogo: options.removeLogo ? true : void 0,
+      themeColor: options.themeColor,
+      accentColor: options.accentColor
+    }
+  );
+  printOutput(
+    {
+      ...result ?? { success: true },
+      logoStorageId: logoStorageId ?? null
+    },
+    runtime.json
+  );
+});
+adminCommand.command("signup-policy").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runQuery(
+    client,
+    api.platformAdmin.queries.getSignupPolicy,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+adminCommand.command("set-signup-policy").option("--blocked <domains>").option("--allowed <domains>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.platformAdmin.mutations.updateSignupEmailDomainPolicy,
+    {
+      blockedDomains: parseList(options.blocked),
+      allowedDomains: parseList(options.allowed)
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+adminCommand.command("sync-disposable-domains").action(async (_options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runAction(
+    client,
+    api.platformAdmin.actions.runDisposableDomainSyncNow,
+    {}
+  );
+  printOutput(result, runtime.json);
+});
+var teamCommand = program.command("team").description("Teams");
+teamCommand.command("list [slug]").option("--limit <n>").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listTeams, {
+    orgSlug,
+    limit: options.limit ? Number(options.limit) : void 0
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("get <teamKey>").action(async (teamKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.getTeam, {
+    orgSlug,
+    teamKey
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("create").requiredOption("--key <key>").requiredOption("--name <name>").option("--description <description>").option("--visibility <visibility>").option("--icon <icon>").option("--color <color>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.createTeam, {
+    orgSlug,
+    key: options.key,
+    name: options.name,
+    description: options.description,
+    visibility: options.visibility,
+    icon: options.icon,
+    color: options.color
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("update <teamKey>").option("--name <name>").option("--description <description>").option("--clear-description").option("--visibility <visibility>").option("--icon <icon>").option("--clear-icon").option("--color <color>").option("--clear-color").action(async (teamKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.updateTeam, {
+    orgSlug,
+    teamKey,
+    name: options.name,
+    description: nullableOption(
+      options.description,
+      options.clearDescription
+    ),
+    visibility: options.visibility,
+    icon: nullableOption(options.icon, options.clearIcon),
+    color: nullableOption(options.color, options.clearColor)
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("delete <teamKey>").action(async (teamKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.deleteTeam, {
+    orgSlug,
+    teamKey
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("members <teamKey>").action(async (teamKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const team = await runAction(client, cliApi.getTeam, { orgSlug, teamKey });
+  const result = await runQuery(client, api.teams.queries.listMembers, {
+    teamId: team.id
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("add-member <teamKey> <member>").option("--role <role>", "member or lead", "member").action(async (teamKey, member, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.addTeamMember, {
+    orgSlug,
+    teamKey,
+    memberName: member,
+    role: options.role
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("remove-member <teamKey> <member>").action(async (teamKey, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.removeTeamMember, {
+    orgSlug,
+    teamKey,
+    memberName: member
+  });
+  printOutput(result, runtime.json);
+});
+teamCommand.command("set-lead <teamKey> <member>").action(async (teamKey, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const leadName = member === "null" ? null : member;
+  const result = await runAction(client, cliApi.changeTeamLead, {
+    orgSlug,
+    teamKey,
+    leadName
+  });
+  printOutput(result, runtime.json);
+});
+var projectCommand = program.command("project").description("Projects");
+projectCommand.command("list [slug]").option("--team <teamKey>").option("--limit <n>").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listProjects, {
+    orgSlug,
+    teamKey: options.team,
+    limit: options.limit ? Number(options.limit) : void 0
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("get <projectKey>").action(async (projectKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.getProject, {
+    orgSlug,
+    projectKey
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("create").requiredOption("--key <key>").requiredOption("--name <name>").option("--description <description>").option("--team <teamKey>").option("--status <statusName>").option("--visibility <visibility>").option("--icon <icon>").option("--color <color>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.createProject, {
+    orgSlug,
+    key: options.key,
+    name: options.name,
+    description: options.description,
+    teamKey: options.team,
+    statusName: options.status,
+    visibility: options.visibility,
+    icon: options.icon,
+    color: options.color
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("update <projectKey>").option("--name <name>").option("--description <description>").option("--team <teamKey>").option("--clear-team").option("--status <statusName>").option("--clear-status").option("--visibility <visibility>").option("--start-date <date>").option("--clear-start-date").option("--due-date <date>").option("--clear-due-date").option("--icon <icon>").option("--clear-icon").option("--color <color>").option("--clear-color").action(async (projectKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.updateProject, {
+    orgSlug,
+    projectKey,
+    name: options.name,
+    description: options.description,
+    teamKey: nullableOption(options.team, options.clearTeam),
+    statusName: nullableOption(options.status, options.clearStatus),
+    visibility: options.visibility,
+    startDate: nullableOption(options.startDate, options.clearStartDate),
+    dueDate: nullableOption(options.dueDate, options.clearDueDate),
+    icon: nullableOption(options.icon, options.clearIcon),
+    color: nullableOption(options.color, options.clearColor)
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("delete <projectKey>").action(async (projectKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.deleteProject, {
+    orgSlug,
+    projectKey
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("members <projectKey>").action(async (projectKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const project = await runAction(client, cliApi.getProject, {
+    orgSlug,
+    projectKey
+  });
+  const result = await runQuery(client, api.projects.queries.listMembers, {
+    projectId: project.id
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("add-member <projectKey> <member>").option("--role <role>", "member or lead", "member").action(async (projectKey, member, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.addProjectMember, {
+    orgSlug,
+    projectKey,
+    memberName: member,
+    role: options.role
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("remove-member <projectKey> <member>").action(async (projectKey, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.removeProjectMember, {
+    orgSlug,
+    projectKey,
+    memberName: member
+  });
+  printOutput(result, runtime.json);
+});
+projectCommand.command("set-lead <projectKey> <member>").action(async (projectKey, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const leadName = member === "null" ? null : member;
+  const result = await runAction(client, cliApi.changeProjectLead, {
+    orgSlug,
+    projectKey,
+    leadName
+  });
+  printOutput(result, runtime.json);
+});
+var issueCommand = program.command("issue").description("Issues");
+issueCommand.command("list [slug]").option("--project <projectKey>").option("--team <teamKey>").option("--limit <n>").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listIssues, {
+    orgSlug,
+    projectKey: options.project,
+    teamKey: options.team,
+    limit: options.limit ? Number(options.limit) : void 0
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("get <issueKey>").action(async (issueKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.getIssue, {
+    orgSlug,
+    issueKey
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("create").requiredOption("--title <title>").option("--description <description>").option("--project <projectKey>").option("--team <teamKey>").option("--priority <priorityName>").option("--visibility <visibility>").option("--assignee <member>").option("--state <stateName>").option("--start-date <date>").option("--due-date <date>").option("--parent <issueKey>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.createIssue, {
+    orgSlug,
+    title: options.title,
+    description: options.description,
+    projectKey: options.project,
+    teamKey: options.team,
+    priorityName: options.priority,
+    visibility: options.visibility,
+    assigneeName: options.assignee,
+    stateName: options.state,
+    startDate: options.startDate,
+    dueDate: options.dueDate,
+    parentIssueKey: options.parent
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("update <issueKey>").option("--title <title>").option("--description <description>").option("--priority <priorityName>").option("--clear-priority").option("--team <teamKey>").option("--clear-team").option("--project <projectKey>").option("--clear-project").option("--visibility <visibility>").option("--assignee <member>").option("--clear-assignee").option("--state <stateName>").option("--start-date <date>").option("--clear-start-date").option("--due-date <date>").option("--clear-due-date").option("--parent <issueKey>").option("--clear-parent").action(async (issueKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.updateIssue, {
+    orgSlug,
+    issueKey,
+    title: options.title,
+    description: options.description,
+    priorityName: nullableOption(options.priority, options.clearPriority),
+    teamKey: nullableOption(options.team, options.clearTeam),
+    projectKey: nullableOption(options.project, options.clearProject),
+    visibility: options.visibility,
+    assigneeName: nullableOption(options.assignee, options.clearAssignee),
+    stateName: options.state,
+    startDate: nullableOption(options.startDate, options.clearStartDate),
+    dueDate: nullableOption(options.dueDate, options.clearDueDate),
+    parentIssueKey: nullableOption(options.parent, options.clearParent)
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("delete <issueKey>").action(async (issueKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.deleteIssue, {
+    orgSlug,
+    issueKey
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("assign <issueKey> <member>").option("--state <stateName>").action(async (issueKey, member, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.assignIssue, {
+    orgSlug,
+    issueKey,
+    assigneeName: member,
+    stateName: options.state
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("unassign <issueKey> <member>").action(async (issueKey, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.unassignIssue, {
+    orgSlug,
+    issueKey,
+    assigneeName: member
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("assignments <issueKey>").action(async (issueKey, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const issueId = await resolveIssueId(client, orgSlug, issueKey);
+  const result = await runQuery(client, api.issues.queries.getAssignments, {
+    issueId
+  });
+  printOutput(result, runtime.json);
+});
+issueCommand.command("set-assignment-state <assignmentId> <state>").action(async (assignmentId, state, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const stateId = await resolveIssueStateId(client, orgSlug, state);
+  const result = await runMutation(
+    client,
+    api.issues.mutations.changeAssignmentState,
+    {
+      assignmentId,
+      stateId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("reassign-assignment <assignmentId> <member>").action(async (assignmentId, member, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const assigneeId = await resolveMemberId(client, orgSlug, member);
+  const result = await runMutation(
+    client,
+    api.issues.mutations.updateAssignmentAssignee,
+    {
+      assignmentId,
+      assigneeId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("remove-assignment <assignmentId>").action(async (assignmentId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const result = await runMutation(
+    client,
+    api.issues.mutations.deleteAssignment,
+    {
+      assignmentId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("set-priority <issueKey> <priority>").action(async (issueKey, priority, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const [issueId, priorityId] = await Promise.all([
+    resolveIssueId(client, orgSlug, issueKey),
+    resolveIssuePriorityId(client, orgSlug, priority)
+  ]);
+  const result = await runMutation(
+    client,
+    api.issues.mutations.changePriority,
+    {
+      issueId,
+      priorityId
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("replace-assignees <issueKey> <members>").action(async (issueKey, members, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const issueId = await resolveIssueId(client, orgSlug, issueKey);
+  const assigneeIds = await Promise.all(
+    parseList(members).map(
+      (member) => resolveMemberId(client, orgSlug, member)
+    )
+  );
+  const result = await runMutation(
+    client,
+    api.issues.mutations.updateAssignees,
+    {
+      issueId,
+      assigneeIds
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("set-estimates <issueKey>").requiredOption("--values <state=hours,...>").action(async (issueKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const issueId = await resolveIssueId(client, orgSlug, issueKey);
+  const estimatedTimes = await parseEstimatedTimes(
+    client,
+    orgSlug,
+    options.values
+  );
+  const result = await runMutation(
+    client,
+    api.issues.mutations.updateEstimatedTimes,
+    {
+      issueId,
+      estimatedTimes
+    }
+  );
+  printOutput(result ?? { success: true }, runtime.json);
+});
+issueCommand.command("comment <issueKey>").requiredOption("--body <body>").action(async (issueKey, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const issue = await runAction(client, cliApi.getIssue, {
+    orgSlug,
+    issueKey
+  });
+  const result = await runMutation(client, api.issues.mutations.addComment, {
+    issueId: issue.id,
+    body: options.body
+  });
+  printOutput(result, runtime.json);
+});
+var documentCommand = program.command("document").description("Documents");
+documentCommand.command("list [slug]").option("--folder-id <id>").option("--limit <n>").action(async (slug, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listDocuments, {
+    orgSlug,
+    folderId: options.folderId,
+    limit: options.limit ? Number(options.limit) : void 0
+  });
+  printOutput(result, runtime.json);
+});
+documentCommand.command("get <documentId>").action(async (documentId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.getDocument, {
+    orgSlug,
+    documentId
+  });
+  printOutput(result, runtime.json);
+});
+documentCommand.command("create").requiredOption("--title <title>").option("--content <content>").option("--team <teamKey>").option("--project <projectKey>").option("--folder-id <id>").option("--visibility <visibility>").option("--icon <icon>").option("--color <color>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.createDocument, {
+    orgSlug,
+    title: options.title,
+    content: options.content,
+    teamKey: options.team,
+    projectKey: options.project,
+    folderId: options.folderId,
+    visibility: options.visibility,
+    icon: options.icon,
+    color: options.color
+  });
+  printOutput(result, runtime.json);
+});
+documentCommand.command("update <documentId>").option("--title <title>").option("--content <content>").option("--team <teamKey>").option("--clear-team").option("--project <projectKey>").option("--clear-project").option("--folder-id <id>").option("--clear-folder").option("--visibility <visibility>").option("--icon <icon>").option("--clear-icon").option("--color <color>").option("--clear-color").action(async (documentId, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.updateDocument, {
+    orgSlug,
+    documentId,
+    title: options.title,
+    content: options.content,
+    teamKey: nullableOption(options.team, options.clearTeam),
+    projectKey: nullableOption(options.project, options.clearProject),
+    folderId: nullableOption(options.folderId, options.clearFolder),
+    visibility: options.visibility,
+    icon: nullableOption(options.icon, options.clearIcon),
+    color: nullableOption(options.color, options.clearColor)
+  });
+  printOutput(result, runtime.json);
+});
+documentCommand.command("move <documentId>").option("--folder-id <id>").option("--clear-folder").action(async (documentId, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const folderId = options.clearFolder ? null : requiredString(options.folderId, "folder-id");
+  const result = await runAction(client, cliApi.moveDocumentToFolder, {
+    orgSlug,
+    documentId,
+    folderId
+  });
+  printOutput(result, runtime.json);
+});
+documentCommand.command("delete <documentId>").action(async (documentId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.deleteDocument, {
+    orgSlug,
+    documentId
+  });
+  printOutput(result, runtime.json);
+});
+var folderCommand = program.command("folder").description("Document folders");
+folderCommand.command("list [slug]").action(async (slug, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime, slug);
+  const result = await runAction(client, cliApi.listFolders, { orgSlug });
+  printOutput(result, runtime.json);
+});
+folderCommand.command("create").requiredOption("--name <name>").option("--description <description>").option("--icon <icon>").option("--color <color>").action(async (options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.createFolder, {
+    orgSlug,
+    name: options.name,
+    description: options.description,
+    icon: options.icon,
+    color: options.color
+  });
+  printOutput(result, runtime.json);
+});
+folderCommand.command("update <folderId>").option("--name <name>").option("--description <description>").option("--clear-description").option("--icon <icon>").option("--clear-icon").option("--color <color>").option("--clear-color").action(async (folderId, options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.updateFolder, {
+    orgSlug,
+    folderId,
+    name: options.name,
+    description: nullableOption(
+      options.description,
+      options.clearDescription
+    ),
+    icon: nullableOption(options.icon, options.clearIcon),
+    color: nullableOption(options.color, options.clearColor)
+  });
+  printOutput(result, runtime.json);
+});
+folderCommand.command("delete <folderId>").action(async (folderId, _options, command) => {
+  const { client, runtime } = await getClient(command);
+  const orgSlug = requireOrg(runtime);
+  const result = await runAction(client, cliApi.deleteFolder, {
+    orgSlug,
+    folderId
+  });
+  printOutput(result, runtime.json);
+});
+async function main() {
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map