@morit/cli 1.1.0 → 1.1.1

package/assets/docs/project-structure.md

@@ -74,6 +74,18 @@ UI에서 참조하는 package 이미지는 최대 512 KiB이고 가로·세로
 계산한 frame 합산 pixel은 최대 16,000,000입니다. 확장자·MIME에 대응하는 magic byte와 실제 이미지
 포맷도 일치해야 합니다.
 
+### 웹 프로젝트에서 아이콘 올리기
+
+developers.moring.co의 **플러그인 프로젝트 관리 → 정보 → 앱 아이콘**에서는 PNG, JPEG, WebP
+파일을 직접 선택하거나 끌어 놓을 수 있습니다. 업로드가 완료되면 이미지는
+`assets/plugin-icon.*`에 저장되고 `manifest.icon`도 같은 revision에서 함께 갱신됩니다. 기존에 이
+화면에서 올린 아이콘을 교체하거나 제거할 때도 파일과 manifest가 원자적으로 함께 반영됩니다.
+
+아이콘은 512 KiB 이하, 가로·세로 각각 4096 px 이하, 전체 16,000,000 pixel 이하만 허용됩니다.
+확장자만 바꾼 파일이나 실제 포맷이 다른 이미지는 서버 검증에서 거부됩니다. MCP가 바이너리 파일을
+직접 전송하지 못하더라도 이 화면에서 한 번 올린 아이콘은 프로젝트 source에 포함되므로 이후 MCP,
+CLI pull·build에서도 원래 이미지 바이트와 `manifest.icon` 경로가 그대로 유지됩니다.
+
 ## 파일별 책임
 
 - `manifest.json`: 패키지 신원, 버전, 전역 권한, 연결과 데이터 정책

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morit/cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Official Morit Developer CLI for Cloud Projects, validation, builds, and deployments",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -259,6 +259,15 @@ export async function pullPluginProject(root, client, force = false) {
   return project;
 }
 
+async function saveLoginCredential(save, credential) {
+  try {
+    await save(credential);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "secure credential storage failed";
+    throw new Error(`Authorization succeeded, but the token could not be stored safely: ${reason}. Run morit logout to recover, then login again`);
+  }
+}
+
 async function login(parsed, options, stdout) {
   const apiUrl = parsed.flags["api-url"] || DEFAULT_API_URL;
   const fetchImpl = options.fetchImpl || fetch;
@@ -266,7 +275,11 @@ async function login(parsed, options, stdout) {
   if (directToken) {
     const client = new MoritCloudClient({ apiUrl, token: directToken, fetchImpl });
     const identity = await client.whoami();
-    await (options.saveCredential || saveCredential)({ token: directToken, apiUrl: client.apiUrl, organizationId: identity.organization_id });
+    await saveLoginCredential(options.saveCredential || saveCredential, {
+      token: directToken,
+      apiUrl: client.apiUrl,
+      organizationId: identity.organization_id,
+    });
     output(stdout, parsed.flags.json ? identity : `Signed in to organization ${identity.organization_id}`, parsed.flags.json);
     return 0;
   }
@@ -282,6 +295,7 @@ async function login(parsed, options, stdout) {
   stdout.write(`Open ${authorization.verification_uri}\nEnter code: ${authorization.user_code}\n`);
   (options.openBrowser || openBrowser)(authorization.verification_uri_complete);
   const deadline = Date.now() + authorization.expires_in * 1000;
+  let networkFailures = 0;
   while (Date.now() < deadline) {
     await (options.sleep || ((milliseconds) => new Promise((resolveSleep) => setTimeout(resolveSleep, milliseconds))))(authorization.interval * 1000);
     try {
@@ -293,7 +307,7 @@ async function login(parsed, options, stdout) {
           retries: 0,
         }),
       );
-      await (options.saveCredential || saveCredential)({
+      await saveLoginCredential(options.saveCredential || saveCredential, {
         token: token.access_token,
         apiUrl: client.apiUrl,
         organizationId: token.organization_id,
@@ -301,7 +315,17 @@ async function login(parsed, options, stdout) {
       output(stdout, parsed.flags.json ? { organization_id: token.organization_id, scopes: token.scopes } : "Morit CLI is connected", parsed.flags.json);
       return 0;
     } catch (error) {
-      if (error instanceof MoritCloudError && error.code === "authorization_pending") continue;
+      if (error instanceof MoritCloudError && error.code === "authorization_pending") {
+        networkFailures = 0;
+        continue;
+      }
+      if (error instanceof MoritCloudError && error.code === "network_error" && ++networkFailures < 3) continue;
+      if (error instanceof MoritCloudError && error.code === "access_denied") {
+        throw new Error("CLI authorization was cancelled");
+      }
+      if (error instanceof MoritCloudError && ["expired_token", "device_code_expired"].includes(error.code)) {
+        throw new Error("CLI authorization expired; run morit login again");
+      }
       throw error;
     }
   }

package/src/secure-store.js

@@ -1,4 +1,4 @@
-import { execFileSync, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir, userInfo } from "node:os";
 import { join } from "node:path";
@@ -8,14 +8,20 @@ const credentialDirectory = join(homedir(), ".morit");
 const credentialPath = join(credentialDirectory, "credentials.json");
 const serviceName = "morit-cli";
 const ACCESS_TOKEN = /^sk_live_[A-Za-z0-9]{32}$/;
+const STORAGE_BY_PLATFORM = { win32: "dpapi", darwin: "keychain", linux: "secret-tool" };
 
 function powershell(script, input = "") {
   const result = spawnSync(
     "powershell.exe",
-    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", `$ErrorActionPreference='Stop';Add-Type -AssemblyName System.Security;${script}`],
     { input, encoding: "utf8", windowsHide: true, maxBuffer: 1024 * 1024 },
   );
-  if (result.status !== 0) throw new Error("Windows credential protection failed");
+  if (result.error?.code === "ENOENT") {
+    throw new Error("Windows PowerShell is required to protect Morit credentials");
+  }
+  if (result.status !== 0 || !result.stdout.trim()) {
+    throw new Error("Windows credential protection failed; verify that Windows PowerShell and DPAPI are available");
+  }
   return result.stdout.trim();
 }
 
@@ -38,55 +44,115 @@ function windowsUnprotect(payload) {
 }
 
 function linuxSecretToolAvailable() {
-  try {
-    execFileSync("secret-tool", ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+  const result = spawnSync("secret-tool", ["--help"], { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+
+function nativeCredential(storage, action, account, token) {
+  let command;
+  let args;
+  if (storage === "keychain") {
+    command = "security";
+    args = action === "store"
+      ? ["add-generic-password", "-a", account, "-s", serviceName, "-w", token, "-U"]
+      : action === "read"
+        ? ["find-generic-password", "-a", account, "-s", serviceName, "-w"]
+        : ["delete-generic-password", "-a", account, "-s", serviceName];
+  } else {
+    if (!linuxSecretToolAvailable()) {
+      throw new Error("Linux Secret Service is unavailable; install secret-tool and unlock a desktop keyring, or use MORIT_ACCESS_TOKEN for this session");
+    }
+    command = "secret-tool";
+    args = action === "store"
+      ? ["store", "--label=Morit CLI", "service", serviceName, "account", account]
+      : action === "read"
+        ? ["lookup", "service", serviceName, "account", account]
+        : ["clear", "service", serviceName, "account", account];
   }
+  const result = spawnSync(command, args, {
+    input: action === "store" && storage === "secret-tool" ? token : undefined,
+    encoding: "utf8",
+    windowsHide: true,
+    maxBuffer: 1024 * 1024,
+  });
+  const label = storage === "keychain" ? "macOS Keychain" : "Linux Secret Service";
+  const stdout = result.stdout?.trim() || "";
+  const stderr = result.stderr?.trim() || "";
+  const missing = action === "delete" && (
+    (storage === "keychain" && result.status === 44)
+    || (storage === "secret-tool" && result.status === 1 && !stderr)
+  );
+  if (result.error?.code === "ENOENT") throw new Error(`${label} command is unavailable`);
+  if (result.status !== 0 && !missing) {
+    throw new Error(`Unable to ${action} the Morit token in ${label}; unlock the secure store and retry`);
+  }
+  if (action === "read" && !stdout) {
+    throw new Error(`The saved Morit token is missing from ${label}; run morit logout and login again`);
+  }
+  return stdout;
+}
+
+function validMetadata(value) {
+  if (!value || typeof value !== "object" || value.version !== 1 || typeof value.api_url !== "string") return false;
+  if (value.storage === "dpapi") return typeof value.payload === "string" && value.payload.length > 0;
+  return (value.storage === "keychain" || value.storage === "secret-tool")
+    && typeof value.account === "string" && value.account.length > 0 && value.account.length <= 256;
 }
 
-async function metadata() {
-  try { return JSON.parse(await readFile(credentialPath, "utf8")); }
-  catch (error) {
+async function metadata({ allowCorrupt = false } = {}) {
+  try {
+    const value = JSON.parse(await readFile(credentialPath, "utf8"));
+    if (!validMetadata(value)) throw new Error("invalid metadata");
+    return value;
+  } catch (error) {
     if (error.code === "ENOENT") return null;
+    if (allowCorrupt) return { corrupt: true };
     throw new Error("Morit credential metadata is unreadable; run morit logout and login again");
   }
 }
 
 async function writeMetadata(value) {
   await mkdir(credentialDirectory, { recursive: true, mode: 0o700 });
-  const temporary = `${credentialPath}.tmp`;
-  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-  await rename(temporary, credentialPath);
-  await chmod(credentialPath, 0o600).catch(() => undefined);
+  await chmod(credentialDirectory, 0o700).catch(() => undefined);
+  const temporary = `${credentialPath}.${process.pid}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(temporary, credentialPath);
+    await chmod(credentialPath, 0o600).catch(() => undefined);
+  } catch (error) {
+    await unlink(temporary).catch(() => undefined);
+    throw new Error("Unable to update Morit credential metadata", { cause: error });
+  }
 }
 
 export async function saveCredential({ token, apiUrl, organizationId }) {
   if (!ACCESS_TOKEN.test(token || "")) throw new Error("Developer access token is invalid");
   const normalizedApiUrl = normalizeApiOrigin(apiUrl);
-  const account = userInfo().username;
-  if (process.platform === "win32") {
-    await writeMetadata({ version: 1, storage: "dpapi", payload: windowsProtect(token), api_url: normalizedApiUrl, organization_id: organizationId });
-    return;
+  const previous = await metadata();
+  const storage = STORAGE_BY_PLATFORM[process.platform];
+  if (!storage) throw new Error(`Secure credential storage is not supported on ${process.platform}`);
+  if (previous && previous.storage !== storage) {
+    throw new Error("Saved credentials belong to a different platform; run morit logout before logging in again");
   }
-  if (process.platform === "darwin") {
-    const result = spawnSync("security", ["add-generic-password", "-a", account, "-s", serviceName, "-w", token, "-U"], {
-      stdio: "ignore",
-    });
-    if (result.status !== 0) throw new Error("Unable to save token in macOS Keychain");
-    await writeMetadata({ version: 1, storage: "keychain", account, api_url: normalizedApiUrl, organization_id: organizationId });
+  if (storage === "dpapi") {
+    await writeMetadata({ version: 1, storage, payload: windowsProtect(token), api_url: normalizedApiUrl, organization_id: organizationId });
     return;
   }
-  if (!linuxSecretToolAvailable()) {
-    throw new Error("A desktop keyring is required; install secret-tool or use MORIT_ACCESS_TOKEN for this session");
+
+  const account = userInfo().username;
+  const previousToken = previous ? nativeCredential(storage, "read", previous.account) : null;
+  nativeCredential(storage, "store", account, token);
+  try {
+    await writeMetadata({ version: 1, storage, account, api_url: normalizedApiUrl, organization_id: organizationId });
+  } catch (error) {
+    try {
+      if (previousToken) nativeCredential(storage, "store", previous.account, previousToken);
+      else nativeCredential(storage, "delete", account);
+    } catch {
+      throw new Error("Credential metadata failed and secure-store recovery also failed; run morit logout before retrying");
+    }
+    throw error;
   }
-  const result = spawnSync("secret-tool", ["store", "--label=Morit CLI", "service", serviceName, "account", account], {
-    input: token,
-    encoding: "utf8",
-  });
-  if (result.status !== 0) throw new Error("Unable to save token in the desktop keyring");
-  await writeMetadata({ version: 1, storage: "secret-tool", account, api_url: normalizedApiUrl, organization_id: organizationId });
 }
 
 export async function loadCredential() {
@@ -107,24 +173,28 @@ export async function loadCredential() {
   if (value.storage === "dpapi" && process.platform === "win32") {
     token = windowsUnprotect(value.payload);
   } else if (value.storage === "keychain" && process.platform === "darwin") {
-    token = execFileSync("security", ["find-generic-password", "-a", value.account, "-s", serviceName, "-w"], { encoding: "utf8" }).trim();
-  } else if (value.storage === "secret-tool" && linuxSecretToolAvailable()) {
-    token = execFileSync("secret-tool", ["lookup", "service", serviceName, "account", value.account], { encoding: "utf8" }).trim();
+    token = nativeCredential(value.storage, "read", value.account);
+  } else if (value.storage === "secret-tool" && process.platform === "linux") {
+    token = nativeCredential(value.storage, "read", value.account);
   } else {
     throw new Error("Saved credentials belong to a different platform; run morit logout and login again");
   }
-  if (!ACCESS_TOKEN.test(token)) throw new Error("Saved Morit credential is invalid");
+  if (!ACCESS_TOKEN.test(token)) throw new Error("Saved Morit credential is invalid; run morit logout and login again");
   return { token, apiUrl, organizationId: value.organization_id, ephemeral: false };
 }
 
 export async function clearCredential() {
-  const value = await metadata();
-  if (value?.storage === "keychain" && process.platform === "darwin") {
-    spawnSync("security", ["delete-generic-password", "-a", value.account, "-s", serviceName], { stdio: "ignore" });
-  } else if (value?.storage === "secret-tool" && linuxSecretToolAvailable()) {
-    spawnSync("secret-tool", ["clear", "service", serviceName, "account", value.account], { stdio: "ignore" });
+  const value = await metadata({ allowCorrupt: true });
+  if (!value) return;
+  if (value.corrupt) {
+    if (process.platform === "darwin") nativeCredential("keychain", "delete", userInfo().username);
+    else if (process.platform === "linux") nativeCredential("secret-tool", "delete", userInfo().username);
+  } else if (value.storage === "keychain" && process.platform === "darwin") {
+    nativeCredential(value.storage, "delete", value.account);
+  } else if (value.storage === "secret-tool" && process.platform === "linux") {
+    nativeCredential(value.storage, "delete", value.account);
   }
   await unlink(credentialPath).catch((error) => {
-    if (error.code !== "ENOENT") throw error;
+    if (error.code !== "ENOENT") throw new Error("Unable to remove Morit credential metadata", { cause: error });
   });
 }