@moloodev/cli 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moloodev/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "bin": {
     "moloo": "./bin/moloo.mjs"
@@ -22,15 +22,15 @@
     "tw-animate-css": "^1.4.0",
     "tsx": "^4.23.13",
     "vite": "^8.2.2",
-    "@moloodev/editor-sdk": "0.4.0",
-    "@moloodev/platform": "0.4.0",
-    "@moloodev/editor-store": "0.4.0",
-    "@moloodev/ui": "0.4.0"
+    "@moloodev/editor-sdk": "0.5.0",
+    "@moloodev/editor-store": "0.5.0",
+    "@moloodev/platform": "0.5.0",
+    "@moloodev/ui": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.3",
     "typescript": "^7.0.2",
-    "@moloodev/typescript-config": "0.4.0"
+    "@moloodev/typescript-config": "0.5.0"
   },
   "publishConfig": {
     "access": "public"

package/src/auth.ts

@@ -72,7 +72,7 @@ export async function login(
 
 export async function loginToken(store = credentialStore(ISSUER), issuer = ISSUER) {
   const tokens = await store.read();
-  if (!tokens) throw new Error("Not logged in. Run moloo login or set MOLOO_SERVICE_TOKEN for CI.");
+  if (!tokens) throw new Error("Not logged in. Run moloo login.");
   if (tokens.expiresAt > Date.now() + 60_000) return tokens.accessToken;
   const updated = await readTokens(
     await oauthPost(issuer, "/oauth2/token", {
@@ -100,22 +100,23 @@ export async function logout(store: CredentialStore = credentialStore(ISSUER), i
   const tokens = await store.read();
   if (tokens) await revokeTokens(issuer, tokens);
   await store.delete();
-  console.log(tokens ? "Logged out." : "Local credentials cleared; no parseable token, server revocation skipped.");
+  console.log(tokens ? "Logged out." : "No valid credentials; local entry cleared.");
 }
 
-export async function publishCredentials(
-  serviceToken: string | undefined,
+async function authorizePublish(issuer: string, scope: string): Promise<Tokens> {
+  if (process.env.CI || !process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Publish scope required. Run moloo editor publish interactively to authorize editor:publish.");
+  }
+  return authorizeLogin(issuer, scope);
+}
+
+export async function publishToken(
   store = credentialStore(ISSUER),
   issuer = ISSUER,
-  authorize = authorizeLogin,
-) {
-  if (serviceToken !== undefined) {
-    const token = serviceToken.trim();
-    if (!token) throw new Error("MOLOO_SERVICE_TOKEN is empty");
-    return { token, bearer: false };
-  }
+  authorize = authorizePublish,
+): Promise<string> {
   const previous = await store.read();
-  if (!previous) throw new Error("Not logged in. Run moloo login or set MOLOO_SERVICE_TOKEN for CI.");
+  if (!previous) throw new Error("Not logged in. Run moloo login.");
   if (!previous.scopes.includes("editor:publish")) {
     const scopes = [...new Set([...previous.scopes, "editor:publish"])];
     const tokens = await authorize(issuer, scopes.join(" "));
@@ -124,9 +125,9 @@ export async function publishCredentials(
       throw new Error("OAuth authorization did not grant the requested publish scopes.");
     }
     await replaceTokens(store, issuer, previous, tokens);
-    return { token: tokens.accessToken, bearer: true };
+    return tokens.accessToken;
   }
-  return { token: await loginToken(store, issuer), bearer: true };
+  return loginToken(store, issuer);
 }
 
 export async function cliIdentity(

package/src/cli.ts

@@ -6,7 +6,7 @@ import { publishEditorPackage } from "./publish";
 import { listWorkspaces, useWorkspace, type WorkspaceOptions } from "./workspace";
 
 const EDITOR_USAGE =
-  "Usage: moloo editor <dev|build|publish> [--dir <path>] [--out-dir <path>] [--view-port <port>] [--workspace <slug>] [--api-url <https-origin>]\nDev view port: 4310 (default)";
+  "Usage: moloo editor <dev|build|publish> [--dir <path>] [--out-dir <path>] [--view-port <port>] [--workspace <slug>]\nDev view port: 4310 (default)";
 const WORKSPACE_USAGE = "Usage: moloo workspace list | use <slug>";
 const USAGE = `Usage: moloo <command>\n\nCommands:\n  login   [--device]\n  logout\n  whoami\n  workspace  list | use <slug>\n  editor  dev | build | publish\n\n${WORKSPACE_USAGE}\n${EDITOR_USAGE}`;
 
@@ -40,10 +40,21 @@ const editorCommands: Record<string, Command> = {
     );
     return 0;
   },
-  async publish(args) {
+  async publish(args, options) {
+    for (let index = 0; index < args.length; index += 2) {
+      if (!["--dir", "--workspace"].includes(args[index] ?? "") ||
+          !args[index + 1] || args[index + 1]?.startsWith("--")) {
+        throw new Error(EDITOR_USAGE);
+      }
+    }
     const result = await publishEditorPackage(packageRootFlag(args), {
-      apiUrl: readFlag(args, "--api-url"),
+      ...options, workspace: readFlag(args, "--workspace"),
     });
+    if (result.status === 202) {
+      const receipt = JSON.parse(result.body) as { data: { id: string } };
+      console.log(`${result.id} 제출됨·심사 필요 ${receipt.data.id}`);
+      return 0;
+    }
     console.log(`${result.id} ${String(result.status)} ${result.body}`);
     return result.status === 200 || result.status === 201 ? 0 : 1;
   },

package/src/index.ts

@@ -16,7 +16,6 @@ export {
   publishEditor,
   publishEditorPackage,
   publishEndpoint,
-  reservedEditorId,
   uploadEndpoint,
 } from "./publish";
 export { readEditorManifest } from "./read-editor-manifest";

package/src/publish.ts

@@ -1,34 +1,31 @@
-import { publishCredentials } from "./auth";
+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;
-  bearer?: boolean;
+  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: input.bearer ? { authorization: `Bearer ${input.token}` } : 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 };
@@ -44,13 +41,14 @@ export async function publishEditor(input: {
 
   const response = await fetch(publishUrl, {
     method: "POST",
+    redirect: "error",
     headers: {
-      ...(input.bearer ? { authorization: `Bearer ${input.token}` } : 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"),
@@ -62,27 +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 credentials = await publishCredentials(options.token ?? process.env.MOLOO_SERVICE_TOKEN);
+  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,
-    ...credentials,
-    apiUrl: options.apiUrl,
-    service: options.service,
+    token,
+    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 {
@@ -99,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);
 }