@moloodev/cli 0.3.0 → 0.5.0

package/src/publish.ts

@@ -1,32 +1,31 @@
+import { publishToken } from "./auth";
 import { createHash } from "node:crypto";
 import { putScriptUpload } from "@moloodev/editor-store/upload";
-import { getApiOrigin } from "@moloodev/platform";
-import { builtinEditors } from "@moloodev/platform/builtin-editors";
-import { buildEditorPackage } from "./editor-views";
+import { getApiOrigin, parseQualifiedName, type PublishTarget } from "@moloodev/platform";
+import { buildEditorPackage, readPackageEditorView } from "./editor-views";
+import { resolveWorkspace, type WorkspaceOptions } from "./workspace";
 
-const DEFAULT_SERVICE = "editor-origin-build";
-
-export function publishEndpoint(apiUrl?: string): string {
-  return `${apiBase(apiUrl)}/v1/revisions/publish`;
+export function publishEndpoint(): string {
+  return `${getApiOrigin("production")}/v1/revisions/publish`;
 }
 
-export function uploadEndpoint(apiUrl?: string): string {
-  return `${apiBase(apiUrl)}/v1/revisions/uploads`;
+export function uploadEndpoint(): string {
+  return `${getApiOrigin("production")}/v1/revisions/uploads`;
 }
 
 export async function publishEditor(input: {
   manifest: Record<string, unknown>;
   script: string;
   token: string;
-  apiUrl?: string;
-  service?: string;
+  target: PublishTarget;
 }): Promise<{ status: number; body: string }> {
-  const uploadUrl = uploadEndpoint(input.apiUrl);
-  const publishUrl = publishEndpoint(input.apiUrl);
-  const service = input.service ?? DEFAULT_SERVICE;
+  const uploadUrl = uploadEndpoint();
+  const publishUrl = publishEndpoint();
   const issued = await fetch(uploadUrl, {
     method: "POST",
-    headers: serviceHeaders(input.token, service),
+    redirect: "error",
+    headers: { authorization: `Bearer ${input.token}`, "content-type": "application/json" },
+    body: JSON.stringify({ target: input.target, manifestId: input.manifest.id }),
   });
   const issuedBody = await issued.text();
   if (issued.status !== 201) return { status: issued.status, body: issuedBody };
@@ -42,13 +41,14 @@ export async function publishEditor(input: {
 
   const response = await fetch(publishUrl, {
     method: "POST",
+    redirect: "error",
     headers: {
-      ...serviceHeaders(input.token, service),
+      authorization: `Bearer ${input.token}`,
       "content-type": "application/json",
     },
     body: JSON.stringify({
+      target: input.target,
       manifest: input.manifest,
-      editorId: reservedEditorId(input.manifest),
       upload: {
         pathname: upload.pathname,
         sha256: createHash("sha256").update(bytes).digest("hex"),
@@ -60,28 +60,31 @@ export async function publishEditor(input: {
 
 export async function publishEditorPackage(
   packageRoot: string,
-  options: { token?: string; apiUrl?: string; service?: string } = {},
+  options: Omit<WorkspaceOptions, "apiOrigin"> & { workspace?: string } = {},
 ): Promise<{ id: string; status: number; body: string }> {
-  const token = (options.token ?? process.env.MOLOO_SERVICE_TOKEN ?? "").trim();
-  if (token.length === 0) throw new Error("MOLOO_SERVICE_TOKEN is empty");
+  const view = readPackageEditorView(packageRoot);
+  const name = parseQualifiedName(view.id);
+  if (!name) throw new Error("Invalid editor manifest id");
+  let target: PublishTarget;
+  if (name.publisher === "moloo") {
+    if (options.workspace !== undefined) throw new Error("Built-in editors do not accept --workspace.");
+    target = { kind: "builtin" };
+  } else {
+    target = { kind: "workspace", workspaceSlug: await resolveWorkspace({
+      flag: options.workspace, store: options.store, configPath: options.configPath,
+    }) };
+  }
+  const token = await publishToken(options.store);
   const built = await buildEditorPackage(packageRoot);
   const result = await publishEditor({
     manifest: built.manifest,
     script: built.script,
     token,
-    apiUrl: options.apiUrl,
-    service: options.service,
+    target,
   });
   return { id: built.id, ...result };
 }
 
-function serviceHeaders(token: string, service: string): Record<string, string> {
-  return {
-    "x-moloo-service-token": token,
-    "x-moloo-service": service,
-  };
-}
-
 function readUpload(text: string): { pathname: string; token: string } | undefined {
   let value: unknown;
   try {
@@ -98,27 +101,6 @@ function readUpload(text: string): { pathname: string; token: string } | undefin
   return { pathname, token };
 }
 
-function apiBase(apiUrl: string | undefined): string {
-  const raw = apiUrl?.trim() ?? "";
-  const base = raw.length === 0 ? getApiOrigin("production") : raw;
-  let url: URL;
-  try {
-    url = new URL(base);
-  } catch {
-    throw new Error("publish API origin is invalid");
-  }
-  if (url.protocol !== "https:") throw new Error("publish API origin must be https");
-  return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
-}
-
-export function reservedEditorId(manifest: Record<string, unknown>): string {
-  const id = manifest.id;
-  if (typeof id !== "string") throw new Error("builtin manifest id is missing");
-  const row = builtinEditors.find((item) => `${item.publisherHandle}.${item.slug}` === id);
-  if (row === undefined) throw new Error(`builtin editor ${id} is missing`);
-  return row.id;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/workspace.ts

@@ -0,0 +1,68 @@
+import { cliIdentity } from "./auth";
+import { readConfig, writeConfig } from "./config";
+import type { CredentialStore } from "./credentials";
+
+export type WorkspaceOptions = {
+  store?: CredentialStore;
+  apiOrigin?: string;
+  configPath?: string;
+};
+
+export async function listWorkspaces(options: WorkspaceOptions = {}): Promise<void> {
+  const { workspaces: available } = await cliIdentity(options.store, options.apiOrigin);
+  const config = await readConfig(options.configPath);
+  for (const workspace of available) {
+    console.log(`${workspace.slug}\t${workspace.name}${workspace.slug === config.workspace ? " (default)" : ""}`);
+  }
+  if (!available.length) console.log("No workspaces.");
+}
+
+export async function useWorkspace(slug: string, options: WorkspaceOptions = {}): Promise<void> {
+  const { workspaces: available } = await cliIdentity(options.store, options.apiOrigin);
+  const workspace = available.find((item) => item.slug === slug);
+  if (!workspace) {
+    throw new Error(`Workspace "${slug}" is not in your memberships. Run moloo workspace use <slug>. Available: ${available.map((item) => item.slug).join(", ") || "none"}.`);
+  }
+  await writeConfig({ workspace: workspace.slug }, options.configPath);
+  console.log(`Default workspace: ${workspace.slug} (${workspace.name})`);
+}
+
+/** Resolve against current memberships even when the slug came from saved config. */
+export async function resolveWorkspace({
+  flag,
+  interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  choose = chooseWorkspace,
+  ...options
+}: WorkspaceOptions & {
+  flag?: string;
+  interactive?: boolean;
+  choose?: (workspaces: { slug: string; name: string }[]) => Promise<string>;
+} = {}): Promise<string> {
+  const { workspaces } = await cliIdentity(options.store, options.apiOrigin);
+  const selected = flag ?? (await readConfig(options.configPath)).workspace;
+  const available = workspaces.map((workspace) => workspace.slug).join(", ") || "none";
+  const guidance = `Run moloo workspace use <slug>. Available: ${available}.`;
+  if (selected !== undefined) {
+    if (workspaces.some((workspace) => workspace.slug === selected)) return selected;
+    throw new Error(`Workspace "${selected}" is not in your memberships. ${guidance}`);
+  }
+  if (workspaces.length === 1 && workspaces[0]) return workspaces[0].slug;
+  if (!workspaces.length || !interactive) throw new Error(`Select a workspace. ${guidance}`);
+  const slug = await choose(workspaces);
+  if (!workspaces.some((workspace) => workspace.slug === slug)) {
+    throw new Error(`Invalid workspace selection. ${guidance}`);
+  }
+  return slug;
+}
+
+async function chooseWorkspace(workspaces: { slug: string; name: string }[]): Promise<string> {
+  const { createInterface } = await import("node:readline/promises");
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const choices = workspaces.map((workspace, index) => `${index + 1}. ${workspace.slug} (${workspace.name})`).join("\n");
+    const answer = (await prompt.question(`${choices}\nWorkspace number: `)).trim();
+    return /^[1-9][0-9]*$/.test(answer) ? workspaces[Number(answer) - 1]?.slug ?? "" : "";
+  } finally {
+    prompt.close();
+  }
+}