@pmate/cli 0.18.0 → 0.20.0

package/dist/index.d.ts

@@ -139,6 +139,16 @@ type QuizCommandArgs = {
     paperId: string;
     apiBaseUrl?: string;
     linkBaseUrl?: string;
+} | {
+    type: Command.Quiz;
+    action: "edit-step";
+    paperId: string;
+    stepId: string;
+    filePath: string;
+    newPaperId?: string;
+    apiBaseUrl?: string;
+    linkBaseUrl?: string;
+    activate: boolean;
 };
 type LinearPrCommandArgs = {
     type: Command.Linear;

package/dist/index.js

@@ -34,24 +34,94 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/namespacedRef.ts
+function parseNamespacedRef(value, options = {}) {
+  const raw = value.trim();
+  const entityLabel = options.entityLabel || "ref";
+  if (!raw) {
+    throw new Error(`Invalid ${entityLabel}.`);
+  }
+  const colonIndex = raw.indexOf(":");
+  if (colonIndex > 0) {
+    const namespace2 = raw.slice(0, colonIndex).trim();
+    const objectId = raw.slice(colonIndex + 1).trim();
+    if (!namespace2 || !objectId) {
+      throw new Error(`Invalid ${entityLabel} "${value}". Use <ns:objectId>.`);
+    }
+    return {
+      namespace: namespace2,
+      objectId,
+      fullId: `${namespace2}:${objectId}`
+    };
+  }
+  const namespace = options.defaultNamespace?.trim();
+  if (namespace) {
+    return {
+      namespace,
+      objectId: raw,
+      fullId: `${namespace}:${raw}`
+    };
+  }
+  throw new Error(`Invalid ${entityLabel} "${value}". Use <ns:objectId>.`);
+}
+function composeNamespacedRef(namespace, objectId) {
+  const normalizedNamespace = namespace.trim();
+  const normalizedObjectId = objectId.trim();
+  return `${normalizedNamespace}:${normalizedObjectId}`;
+}
+function formatNamespacedDisplayId(namespace, objectIdOrFullId) {
+  const raw = objectIdOrFullId.trim();
+  if (raw.includes(":")) {
+    return raw;
+  }
+  const ns = namespace?.trim();
+  if (!ns) {
+    return raw;
+  }
+  return composeNamespacedRef(ns, raw);
+}
+var init_namespacedRef = __esm({
+  "src/namespacedRef.ts"() {
+    "use strict";
+  }
+});
+
 // src/sessionStore.ts
 function buildSessionStorePath() {
   return import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate", "session.json");
 }
+function assertValidAppRef(appRef) {
+  return parseNamespacedRef(appRef, { entityLabel: "app ref" }).fullId;
+}
 function saveLoginSession(session, requestedApp = DEFAULT_APP_ID) {
   const store = loadExistingSessionStoreOrEmpty();
-  const app = resolveStoredAppId(session, requestedApp);
+  const app = assertValidAppRef(requestedApp);
+  const sessionApp = session.session?.app?.trim();
+  if (!sessionApp) {
+    throw new Error("Missing app in login session payload.");
+  }
+  const normalizedSessionApp = assertValidAppRef(sessionApp);
+  if (normalizedSessionApp !== app) {
+    throw new Error(
+      `Session app mismatch. requested=${app}, received=${normalizedSessionApp}`
+    );
+  }
+  const accountId = session.session.identity?.accountId?.trim();
+  const token = session.token?.trim();
+  const issuedAt = session.session.issuedAt?.trim();
+  const expiresAt = session.session.expiresAt?.trim();
+  if (!accountId || !token || !issuedAt || !expiresAt) {
+    throw new Error("Invalid login session payload.");
+  }
   const nextSession = {
-    ...session,
-    app,
-    session: {
-      ...session.session,
-      ...session.session.app ? {} : { app }
-    },
+    token,
+    accountId,
+    issuedAt,
+    expiresAt,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   store.sessions[app] = nextSession;
-  store.activeApp = app;
+  store.activeAppRef = app;
   writeSessionStore(store);
   return {
     app,
@@ -67,7 +137,9 @@ function readRequiredSession(options) {
   }
   const token = session.token?.trim();
   if (!token) {
-    throw new Error(`Missing token in ${sessionPath}. Run "pmate login --app ${resolvedApp}" again.`);
+    throw new Error(
+      `Missing token in ${sessionPath}. Run "pmate login --app ${resolvedApp}" again.`
+    );
   }
   return {
     ...session,
@@ -82,7 +154,7 @@ function loadExistingSessionStoreOrEmpty() {
   if (!(0, import_node_fs2.existsSync)(sessionPath)) {
     return {
       version: SESSION_STORE_VERSION,
-      activeApp: DEFAULT_APP_ID,
+      activeAppRef: DEFAULT_APP_ID,
       sessions: {}
     };
   }
@@ -104,31 +176,74 @@ function normalizeStore(value) {
       `Invalid session store format in ${buildSessionStorePath()}. Run "pmate login" again.`
     );
   }
-  return {
-    version: SESSION_STORE_VERSION,
-    activeApp: value.activeApp || DEFAULT_APP_ID,
-    sessions: value.sessions || {}
-  };
+  return value;
 }
 function isSessionStore(value) {
-  return !!value && typeof value === "object" && "version" in value && "sessions" in value && typeof value.sessions === "object";
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.version !== SESSION_STORE_VERSION) {
+    return false;
+  }
+  if (typeof candidate.activeAppRef !== "string") {
+    return false;
+  }
+  let normalizedActiveApp;
+  try {
+    normalizedActiveApp = assertValidAppRef(candidate.activeAppRef);
+  } catch {
+    return false;
+  }
+  if (normalizedActiveApp !== candidate.activeAppRef) {
+    return false;
+  }
+  if (!candidate.sessions || typeof candidate.sessions !== "object") {
+    return false;
+  }
+  if (!(normalizedActiveApp in candidate.sessions)) {
+    return false;
+  }
+  for (const [appRef, session] of Object.entries(candidate.sessions)) {
+    try {
+      if (assertValidAppRef(appRef) !== appRef) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+    if (!isStoredSession(session)) {
+      return false;
+    }
+  }
+  return true;
 }
-function resolveStoredAppId(session, fallbackApp) {
-  return session.session?.app?.trim() || session.app?.trim() || fallbackApp.trim() || DEFAULT_APP_ID;
+function isStoredSession(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const session = value;
+  return typeof session.token === "string" && !!session.token.trim() && typeof session.accountId === "string" && !!session.accountId.trim() && typeof session.issuedAt === "string" && !!session.issuedAt.trim() && typeof session.expiresAt === "string" && !!session.expiresAt.trim() && typeof session.updatedAt === "string" && !!session.updatedAt.trim();
 }
 function resolveReadApp(store, options) {
   const requestedApp = options?.app?.trim();
   if (requestedApp) {
-    return requestedApp;
+    return assertValidAppRef(requestedApp);
   }
   const preferredApp = options?.preferredApp?.trim();
-  if (preferredApp && store.sessions[preferredApp]) {
-    return preferredApp;
+  if (preferredApp) {
+    const normalizedPreferred = assertValidAppRef(preferredApp);
+    if (store.sessions[normalizedPreferred]) {
+      return normalizedPreferred;
+    }
   }
-  if (options?.fallbackToActiveApp && store.activeApp && store.sessions[store.activeApp]) {
-    return store.activeApp;
+  if (options?.fallbackToActiveApp && store.sessions[store.activeAppRef]) {
+    return store.activeAppRef;
   }
-  return preferredApp || store.activeApp || DEFAULT_APP_ID;
+  if (preferredApp) {
+    return assertValidAppRef(preferredApp);
+  }
+  return store.activeAppRef;
 }
 function writeSessionStore(store) {
   const sessionPath = buildSessionStorePath();
@@ -154,8 +269,9 @@ var init_sessionStore = __esm({
     import_node_fs2 = require("fs");
     import_node_os2 = __toESM(require("os"));
     import_node_path3 = __toESM(require("path"));
-    DEFAULT_APP_ID = "@pmate/cli";
-    SESSION_STORE_VERSION = 2;
+    init_namespacedRef();
+    DEFAULT_APP_ID = "pmate:cli";
+    SESSION_STORE_VERSION = 3;
   }
 });
 
@@ -13025,23 +13141,24 @@ var ListCommandHandler = class {
 };
 
 // src/commands/LoginCommandHandler.ts
-var import_node_http = require("http");
 var import_node_child_process = require("child_process");
+var import_node_http = require("http");
 init_sessionStore();
 var AUTH_UI_BASE_URL = "https://auth.pmate.chat";
 var AUTH_API_BASE_URL = "https://auth-api-v2.pmate.chat";
 var CALLBACK_PATH = "/pmate-login-callback";
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
 function buildHostedLoginUrl(redirectUrl, appId = DEFAULT_APP_ID) {
+  const resolvedApp = assertValidAppRef(appId);
   const url = new URL(AUTH_UI_BASE_URL);
   url.searchParams.set("redirect", redirectUrl);
-  url.searchParams.set("app", appId);
+  url.searchParams.set("app", resolvedApp);
   return url.toString();
 }
 var LoginCommandHandler = class {
   async handle(args) {
     const callback = await this.startCallbackServer();
-    const appId = args.app?.trim() || DEFAULT_APP_ID;
+    const appId = assertValidAppRef(args.app?.trim() || DEFAULT_APP_ID);
     const loginUrl = buildHostedLoginUrl(callback.redirectUrl, appId);
     let savedSession = null;
     ui.info("Opening browser for login.", {
@@ -13058,7 +13175,7 @@ var LoginCommandHandler = class {
     });
     try {
       const token = await callback.waitForToken;
-      const loginResponse = await this.fetchSession(token, appId);
+      const loginResponse = await this.exchangeSession(token, appId);
       savedSession = saveLoginSession(loginResponse, appId);
     } finally {
       await callback.close();
@@ -13069,26 +13186,26 @@ var LoginCommandHandler = class {
       );
     }
   }
-  async fetchSession(token, appId) {
-    const url = new URL(`${AUTH_API_BASE_URL}/session`);
-    url.searchParams.set("app", appId);
-    const response = await fetch(url.toString(), {
-      method: "GET",
+  async exchangeSession(token, appId) {
+    const response = await fetch(`${AUTH_API_BASE_URL}/session/exchange`, {
+      method: "POST",
       headers: {
+        "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
-      }
+      },
+      body: JSON.stringify({ app: appId })
     });
     if (!response.ok) {
       const detail = await response.text();
       throw new Error(
-        `Failed to validate session (${response.status}): ${detail || response.statusText}`
+        `Failed to exchange app session (${response.status}): ${detail || response.statusText}`
       );
     }
     const resp = await response.json();
-    return {
-      ...resp.data,
-      token
-    };
+    if (!resp?.data?.session?.app || resp.data.session.app !== appId) {
+      throw new Error("Invalid exchange response: app-scoped session mismatch.");
+    }
+    return resp.data;
   }
   async startCallbackServer() {
     let resolveToken;
@@ -18097,6 +18214,26 @@ async function viewQuizPaper({
     data
   };
 }
+async function getQuizPaper({
+  fetchImpl = fetch,
+  apiBaseUrl,
+  linkBaseUrl,
+  paperId,
+  token
+}) {
+  const viewed = await viewQuizPaper({
+    fetchImpl,
+    apiBaseUrl,
+    linkBaseUrl,
+    paperId,
+    token
+  });
+  const paper = viewed.data;
+  if (!paper || !Array.isArray(paper.steps)) {
+    throw new Error("\u67E5\u770B\u8BD5\u5377\u5931\u8D25\uFF1A\u8FD4\u56DE\u6570\u636E\u4E0D\u5305\u542B\u6709\u6548 steps\u3002");
+  }
+  return paper;
+}
 
 // src/commands/QuizCommandHandler.ts
 var QuizCommandHandler = class {
@@ -18128,6 +18265,51 @@ var QuizCommandHandler = class {
       }
       return;
     }
+    if (args.action === "edit-step") {
+      const basePaper = await getQuizPaper({
+        apiBaseUrl,
+        linkBaseUrl,
+        paperId: args.paperId,
+        token: session.token
+      });
+      const targetIndex = basePaper.steps.findIndex((item) => item.stepId === args.stepId);
+      if (targetIndex < 0) {
+        throw new Error(`\u672A\u627E\u5230 stepId=${args.stepId}\uFF0C\u65E0\u6CD5\u66F4\u65B0\u8BE5\u9898\u76EE\u3002`);
+      }
+      const resolvedFilePath2 = import_node_path14.default.resolve(process.cwd(), args.filePath);
+      const nextStep = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath2, "utf8"));
+      nextStep.stepId = args.stepId;
+      const nextSteps = [...basePaper.steps];
+      nextSteps[targetIndex] = nextStep;
+      const nextPaperId = args.newPaperId || `${args.paperId}-rev-${this.timestampTag()}`;
+      const result2 = await publishQuizPaper({
+        apiBaseUrl,
+        linkBaseUrl,
+        paperId: nextPaperId,
+        payload: {
+          eyebrow: basePaper.eyebrow ?? "",
+          completionTitle: basePaper.completionTitle ?? "",
+          completionSummaryPerfect: basePaper.completionSummaryPerfect ?? "",
+          completionSummaryReview: basePaper.completionSummaryReview ?? "",
+          steps: nextSteps
+        },
+        token: session.token,
+        activate: args.activate
+      });
+      if (result2.status === "draft") {
+        ui.success("Quiz \u5355\u9898\u4FEE\u8BA2\u7A3F\u5DF2\u521B\u5EFA", result2.previewLink);
+        ui.info("\u6765\u6E90\u8BD5\u5377", args.paperId);
+        ui.info("\u4FEE\u8BA2\u9898\u76EE", args.stepId);
+        ui.info("\u65B0\u8BD5\u5377", nextPaperId);
+        ui.info("\u4E0B\u4E00\u6B65", `pmate quiz activate --paper-id ${nextPaperId}`);
+        return;
+      }
+      ui.success("Quiz \u5355\u9898\u4FEE\u8BA2\u7A3F\u5DF2\u53D1\u5E03", result2.link);
+      ui.info("\u6765\u6E90\u8BD5\u5377", args.paperId);
+      ui.info("\u4FEE\u8BA2\u9898\u76EE", args.stepId);
+      ui.info("\u65B0\u8BD5\u5377", nextPaperId);
+      return;
+    }
     const resolvedFilePath = import_node_path14.default.resolve(process.cwd(), args.filePath);
     const payload = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath, "utf8"));
     const result = await publishQuizPaper({
@@ -18146,6 +18328,19 @@ var QuizCommandHandler = class {
     }
     ui.success("Quiz \u5DF2\u53D1\u5E03", result.link);
   }
+  timestampTag() {
+    const now = /* @__PURE__ */ new Date();
+    const pad = (value) => String(value).padStart(2, "0");
+    return [
+      now.getFullYear(),
+      pad(now.getMonth() + 1),
+      pad(now.getDate()),
+      "-",
+      pad(now.getHours()),
+      pad(now.getMinutes()),
+      pad(now.getSeconds())
+    ].join("");
+  }
 };
 
 // src/commands/CollectCommandHandler.ts
@@ -18912,54 +19107,8 @@ var NamespaceRegistry = class {
   }
 };
 
-// src/namespacedRef.ts
-function parseNamespacedRef(value, options = {}) {
-  const raw = value.trim();
-  const entityLabel = options.entityLabel || "ref";
-  if (!raw) {
-    throw new Error(`Invalid ${entityLabel}.`);
-  }
-  const colonIndex = raw.indexOf(":");
-  if (colonIndex > 0) {
-    const namespace2 = raw.slice(0, colonIndex).trim();
-    const objectId = raw.slice(colonIndex + 1).trim();
-    if (!namespace2 || !objectId) {
-      throw new Error(`Invalid ${entityLabel} "${value}". Use <ns:objectId>.`);
-    }
-    return {
-      namespace: namespace2,
-      objectId,
-      fullId: `${namespace2}:${objectId}`
-    };
-  }
-  const namespace = options.defaultNamespace?.trim();
-  if (namespace) {
-    return {
-      namespace,
-      objectId: raw,
-      fullId: `${namespace}:${raw}`
-    };
-  }
-  throw new Error(`Invalid ${entityLabel} "${value}". Use <ns:objectId>.`);
-}
-function composeNamespacedRef(namespace, objectId) {
-  const normalizedNamespace = namespace.trim();
-  const normalizedObjectId = objectId.trim();
-  return `${normalizedNamespace}:${normalizedObjectId}`;
-}
-function formatNamespacedDisplayId(namespace, objectIdOrFullId) {
-  const raw = objectIdOrFullId.trim();
-  if (raw.includes(":")) {
-    return raw;
-  }
-  const ns = namespace?.trim();
-  if (!ns) {
-    return raw;
-  }
-  return composeNamespacedRef(ns, raw);
-}
-
 // src/commands/AgentCommandHandler.ts
+init_namespacedRef();
 var AgentCommandHandler = class {
   async handle(args) {
     const token = this.readToken();
@@ -19423,6 +19572,7 @@ var StoreCommandHandler = class {
 var import_node_fs13 = require("fs");
 var import_node_path18 = __toESM(require("path"));
 init_sessionStore();
+init_namespacedRef();
 var AppCommandHandler = class {
   async handle(args) {
     const token = this.readToken();
@@ -20130,6 +20280,7 @@ function normalizeRepository(repository) {
 }
 
 // src/commands/ServiceCommandHandler.ts
+init_namespacedRef();
 var ServiceCommandHandler = class {
   async handle(args) {
     const baseUrl = this.resolveBaseUrl(args.baseUrl);
@@ -20645,6 +20796,7 @@ var AccountCommandHandler = class {
 };
 
 // src/agentCommandParser.ts
+init_namespacedRef();
 var DEFAULT_AGENT_NAMESPACE = "pmate";
 function parseAgentArgs(tokens) {
   const rest = [...tokens];
@@ -21153,6 +21305,7 @@ function parsePage(value) {
 }
 
 // src/appCommandParser.ts
+init_namespacedRef();
 function parseAppArgs(tokens) {
   const rest = [...tokens];
   const rawAction = rest.shift();
@@ -21342,6 +21495,7 @@ function parseBareRenameId2(value, entityName) {
 }
 
 // src/serviceCommandParser.ts
+init_namespacedRef();
 function parseServiceArgs(tokens) {
   const rest = [...tokens];
   const rawAction = rest.shift();
@@ -21826,6 +21980,7 @@ var HELP_TEXT = [
   `  ${import_chalk3.default.gray("                  publish --file <json> --paper-id <id> [--activate]")}`,
   `  ${import_chalk3.default.gray("                  activate --paper-id <id>")}`,
   `  ${import_chalk3.default.gray("                  view --paper-id <id>")}`,
+  `  ${import_chalk3.default.gray("                  edit-step --paper-id <id> --step-id <step-id> --file <step.json> [--new-paper-id <id>] [--activate]")}`,
   `  ${import_chalk3.default.cyan("linear")}           Create Linear issues`,
   `  ${import_chalk3.default.gray("                  (default) create via REPL")}`,
   `  ${import_chalk3.default.gray("                  create --repl [--cwd <dir>]")}`,
@@ -22530,6 +22685,63 @@ function parseQuizArgs(tokens) {
       linkBaseUrl
     };
   }
+  if (action === "edit-step") {
+    let paperId;
+    let stepId;
+    let filePath;
+    let newPaperId;
+    let apiBaseUrl;
+    let linkBaseUrl;
+    let activate = false;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--paper-id":
+          paperId = requireValue8(rest, token);
+          break;
+        case "--step-id":
+          stepId = requireValue8(rest, token);
+          break;
+        case "--file":
+          filePath = requireValue8(rest, token);
+          break;
+        case "--new-paper-id":
+          newPaperId = requireValue8(rest, token);
+          break;
+        case "--base-url":
+          apiBaseUrl = requireValue8(rest, token);
+          break;
+        case "--link-base":
+          linkBaseUrl = requireValue8(rest, token);
+          break;
+        case "--activate":
+          activate = true;
+          break;
+        default:
+          throw new Error(`Unknown quiz edit-step option: ${token}`);
+      }
+    }
+    if (!paperId) {
+      throw new Error("Missing --paper-id. Usage: quiz edit-step --paper-id <id> --step-id <id> --file <step.json>.");
+    }
+    if (!stepId) {
+      throw new Error("Missing --step-id. Usage: quiz edit-step --paper-id <id> --step-id <id> --file <step.json>.");
+    }
+    if (!filePath) {
+      throw new Error("Missing --file. Usage: quiz edit-step --paper-id <id> --step-id <id> --file <step.json>.");
+    }
+    return {
+      type: "quiz" /* Quiz */,
+      action: "edit-step",
+      paperId,
+      stepId,
+      filePath,
+      newPaperId,
+      apiBaseUrl,
+      linkBaseUrl,
+      activate
+    };
+  }
   throw new Error(`Unknown quiz action: ${action}`);
 }
 function parseLinearArgs(tokens) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {