@aaronshaf/plane 0.1.11 → 1.0.0

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11",
+  "version": "1.0.0",
   "description": "CLI for the Plane project management API",
   "keywords": [
     "plane",

package/src/api.ts

@@ -38,6 +38,8 @@ function request(
 	return Effect.tryPromise({
 		try: async () => {
 			const { token, host, workspace } = getConfig();
+			if (!token) throw new Error("No API token configured. Run 'plane init' or set PLANE_API_TOKEN.");
+			if (!workspace) throw new Error("No workspace configured. Run 'plane init' or set PLANE_WORKSPACE.");
 			let url = `${host}/api/v1/workspaces/${workspace}/${path}`;
 
 			// Always expand state on issue list/get calls (not intake-issues/ or cycle-issues/)

package/src/app.ts

@@ -44,7 +44,7 @@ ALL SUBCOMMANDS
   cycles              list | issues (list, add)
   modules             list | issues (list, add, remove)
   intake              list | accept | reject
-  pages               list | get
+  pages               list | get | create | update | delete | archive | unarchive | lock | unlock | duplicate
   states list         List workflow states for a project
   labels list         List labels for a project
   members list        List members of a project
@@ -74,5 +74,5 @@ FOR AI AGENTS / BOTS
 
 export const cli = Command.run(plane, {
 	name: "plane",
-	version: "0.1.0",
+	version: "0.1.11",
 });

package/src/commands/issue.ts

@@ -79,7 +79,7 @@ const titleUpdateOption = Options.optional(Options.text("title")).pipe(
 );
 
 const descriptionOption = Options.optional(Options.text("description")).pipe(
-	Options.withDescription("Issue description (plain text, stored as HTML)"),
+	Options.withDescription("Issue description as HTML (e.g. '<p>Details</p>')"),
 );
 
 const assigneeOption = Options.optional(Options.text("assignee")).pipe(
@@ -120,26 +120,25 @@ export function issueUpdateHandler({
 
 		const body: IssueUpdatePayload = {};
 
-		if (state._tag === "Some") {
+		if (Option.isSome(state)) {
 			body.state = yield* getStateId(projectId, state.value);
 		}
-		if (priority._tag === "Some") {
+		if (Option.isSome(priority)) {
 			body.priority = priority.value;
 		}
-		if (title._tag === "Some") {
+		if (Option.isSome(title)) {
 			body.name = title.value;
 		}
-		if (description._tag === "Some") {
-			const escaped = escapeHtmlText(description.value);
-			body.description_html = `<p>${escaped}</p>`;
+		if (Option.isSome(description)) {
+			body.description_html = description.value;
 		}
 		if (noAssignee) {
 			body.assignees = [];
-		} else if (assignee._tag === "Some") {
+		} else if (Option.isSome(assignee)) {
 			const memberId = yield* getMemberId(assignee.value);
 			body.assignees = [memberId];
 		}
-		if (label._tag === "Some") {
+		if (Option.isSome(label)) {
 			const labelId = yield* getLabelId(projectId, label.value);
 			body.label_ids = [labelId];
 		}
@@ -234,7 +233,7 @@ const createStateOption = Options.optional(Options.text("state")).pipe(
 const createDescriptionOption = Options.optional(
 	Options.text("description"),
 ).pipe(
-	Options.withDescription("Issue description (plain text, stored as HTML)"),
+	Options.withDescription("Issue description as HTML (e.g. '<p>Details</p>')"),
 );
 
 const createAssigneeOption = Options.optional(Options.text("assignee")).pipe(
@@ -265,18 +264,17 @@ export function issueCreateHandler({
 	return Effect.gen(function* () {
 		const { key, id: projectId } = yield* resolveProject(project);
 		const body: IssueCreatePayload = { name: title };
-		if (priority._tag === "Some") body.priority = priority.value;
-		if (state._tag === "Some")
+		if (Option.isSome(priority)) body.priority = priority.value;
+		if (Option.isSome(state))
 			body.state = yield* getStateId(projectId, state.value);
-		if (description._tag === "Some") {
-			const escaped = escapeHtmlText(description.value);
-			body.description_html = `<p>${escaped}</p>`;
+		if (Option.isSome(description)) {
+			body.description_html = description.value;
 		}
-		if (assignee._tag === "Some") {
+		if (Option.isSome(assignee)) {
 			const memberId = yield* getMemberId(assignee.value);
 			body.assignees = [memberId];
 		}
-		if (label._tag === "Some") {
+		if (Option.isSome(label)) {
 			const labelId = yield* getLabelId(projectId, label.value);
 			body.label_ids = [labelId];
 		}
@@ -403,7 +401,7 @@ export function issueLinkAddHandler({
 		const { projectId, seq } = yield* parseIssueRef(ref);
 		const issue = yield* findIssueBySeq(projectId, seq);
 		const body: Record<string, string> = { url };
-		if (title._tag === "Some") body["title"] = title.value;
+		if (Option.isSome(title)) body["title"] = title.value;
 		const raw = yield* api.post(
 			`projects/${projectId}/issues/${issue.id}/issue-links/`,
 			body,
@@ -627,7 +625,7 @@ export function issueWorklogsAddHandler({
 		const { projectId, seq } = yield* parseIssueRef(ref);
 		const issue = yield* findIssueBySeq(projectId, seq);
 		const body: WorklogPayload = { duration };
-		if (description._tag === "Some") body.description = description.value;
+		if (Option.isSome(description)) body.description = description.value;
 		const raw = yield* api.post(
 			`projects/${projectId}/issues/${issue.id}/worklogs/`,
 			body,

package/src/commands/pages.ts

@@ -1,5 +1,5 @@
-import { Command, Args } from "@effect/cli";
-import { Console, Effect } from "effect";
+import { Command, Args, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
 import { api, decodeOrFail } from "../api.js";
 import { PagesResponseSchema, PageSchema } from "../config.js";
 import { resolveProject } from "../resolve.js";
@@ -9,6 +9,25 @@ const projectArg = Args.text({ name: "project" }).pipe(
 	Args.withDescription("Project identifier (e.g. PROJ, WEB, OPS)"),
 );
 
+const pageIdArg = Args.text({ name: "page-id" }).pipe(
+	Args.withDescription("Page UUID (from 'plane pages list')"),
+);
+
+const nameOption = Options.text("name").pipe(
+	Options.withDescription("Page name/title"),
+);
+
+const nameOptionalOption = Options.optional(Options.text("name")).pipe(
+	Options.withDescription("New page name/title"),
+);
+
+const descriptionOption = Options.optional(Options.text("description")).pipe(
+	Options.withDescription("Page description as HTML (e.g. '<p>Hello</p>')"),
+);
+
+interface PageCreatePayload { name: string; description_html?: string; }
+interface PageUpdatePayload { name?: string; description_html?: string; }
+
 // --- pages list ---
 
 export function pagesListHandler({ project }: { project: string }) {
@@ -48,10 +67,6 @@ export const pagesList = Command.make(
 
 // --- pages get ---
 
-const pageIdArg = Args.text({ name: "page-id" }).pipe(
-	Args.withDescription("Page UUID (from 'plane pages list')"),
-);
-
 export function pagesGetHandler({
 	project,
 	pageId,
@@ -77,11 +92,241 @@ export const pagesGet = Command.make(
 	),
 );
 
+// --- pages create ---
+
+export function pagesCreateHandler({
+	project,
+	name,
+	description,
+}: {
+	project: string;
+	name: string;
+	description: Option.Option<string>;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		const body: PageCreatePayload = { name };
+		if (Option.isSome(description)) {
+			body.description_html = description.value;
+		}
+		const raw = yield* api.post(`projects/${id}/pages/`, body);
+		const page = yield* decodeOrFail(PageSchema, raw);
+		yield* Console.log(`Created page ${page.id}: ${page.name}`);
+	});
+}
+
+export const pagesCreate = Command.make(
+	"create",
+	{ project: projectArg, name: nameOption, description: descriptionOption },
+	pagesCreateHandler,
+).pipe(
+	Command.withDescription(
+		"Create a new page.\n\nExample:\n  plane pages create --name \"My Page\" PROJ",
+	),
+);
+
+// --- pages update ---
+
+export function pagesUpdateHandler({
+	project,
+	pageId,
+	name,
+	description,
+}: {
+	project: string;
+	pageId: string;
+	name: Option.Option<string>;
+	description: Option.Option<string>;
+}) {
+	return Effect.gen(function* () {
+		if (Option.isNone(name) && Option.isNone(description)) {
+			yield* Effect.fail(new Error("provide at least --name or --description"));
+		}
+		const { id } = yield* resolveProject(project);
+		const body: PageUpdatePayload = {};
+		if (Option.isSome(name)) body.name = name.value;
+		if (Option.isSome(description)) body.description_html = description.value;
+		const raw = yield* api.patch(`projects/${id}/pages/${pageId}/`, body);
+		const page = yield* decodeOrFail(PageSchema, raw);
+		yield* Console.log(`Updated page ${page.id}: ${page.name}`);
+	});
+}
+
+export const pagesUpdate = Command.make(
+	"update",
+	{ project: projectArg, pageId: pageIdArg, name: nameOptionalOption, description: descriptionOption },
+	pagesUpdateHandler,
+).pipe(
+	Command.withDescription(
+		"Update a page's name or description.\n\nExample:\n  plane pages update --name \"New Title\" PROJ <page-id>",
+	),
+);
+
+// --- pages delete ---
+
+export function pagesDeleteHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		yield* api.delete(`projects/${id}/pages/${pageId}/`);
+		yield* Console.log(`Deleted page ${pageId}`);
+	});
+}
+
+export const pagesDelete = Command.make(
+	"delete",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesDeleteHandler,
+).pipe(
+	Command.withDescription(
+		"Delete a page.\n\nExample:\n  plane pages delete PROJ <page-id>",
+	),
+);
+
+// --- pages archive ---
+
+export function pagesArchiveHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		yield* api.post(`projects/${id}/pages/${pageId}/archive/`, {});
+		yield* Console.log(`Archived page ${pageId}`);
+	});
+}
+
+export const pagesArchive = Command.make(
+	"archive",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesArchiveHandler,
+).pipe(
+	Command.withDescription(
+		"Archive a page.\n\nExample:\n  plane pages archive PROJ <page-id>",
+	),
+);
+
+// --- pages unarchive ---
+
+export function pagesUnarchiveHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		yield* api.delete(`projects/${id}/pages/${pageId}/archive/`);
+		yield* Console.log(`Unarchived page ${pageId}`);
+	});
+}
+
+export const pagesUnarchive = Command.make(
+	"unarchive",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesUnarchiveHandler,
+).pipe(
+	Command.withDescription(
+		"Unarchive a page.\n\nExample:\n  plane pages unarchive PROJ <page-id>",
+	),
+);
+
+// --- pages lock ---
+
+export function pagesLockHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		yield* api.post(`projects/${id}/pages/${pageId}/lock/`, {});
+		yield* Console.log(`Locked page ${pageId}`);
+	});
+}
+
+export const pagesLock = Command.make(
+	"lock",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesLockHandler,
+).pipe(
+	Command.withDescription(
+		"Lock a page (prevent edits).\n\nExample:\n  plane pages lock PROJ <page-id>",
+	),
+);
+
+// --- pages unlock ---
+
+export function pagesUnlockHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		yield* api.delete(`projects/${id}/pages/${pageId}/lock/`);
+		yield* Console.log(`Unlocked page ${pageId}`);
+	});
+}
+
+export const pagesUnlock = Command.make(
+	"unlock",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesUnlockHandler,
+).pipe(
+	Command.withDescription(
+		"Unlock a page.\n\nExample:\n  plane pages unlock PROJ <page-id>",
+	),
+);
+
+// --- pages duplicate ---
+
+export function pagesDuplicateHandler({
+	project,
+	pageId,
+}: {
+	project: string;
+	pageId: string;
+}) {
+	return Effect.gen(function* () {
+		const { id } = yield* resolveProject(project);
+		const raw = yield* api.post(`projects/${id}/pages/${pageId}/duplicate/`, {});
+		const page = yield* decodeOrFail(PageSchema, raw);
+		yield* Console.log(`Duplicated page ${page.id}: ${page.name}`);
+	});
+}
+
+export const pagesDuplicate = Command.make(
+	"duplicate",
+	{ project: projectArg, pageId: pageIdArg },
+	pagesDuplicateHandler,
+).pipe(
+	Command.withDescription(
+		"Duplicate a page.\n\nExample:\n  plane pages duplicate PROJ <page-id>",
+	),
+);
+
 // --- pages (parent) ---
 
 export const pages = Command.make("pages").pipe(
 	Command.withDescription(
-		"Manage project pages (documentation). Subcommands: list, get\n\nExamples:\n  plane pages list PROJ\n  plane pages get PROJ <page-id>",
+		"Manage project pages (documentation). Subcommands: list, get, create, update, delete, archive, unarchive, lock, unlock, duplicate\n\nExamples:\n  plane pages list PROJ\n  plane pages get PROJ <page-id>",
 	),
-	Command.withSubcommands([pagesList, pagesGet]),
+	Command.withSubcommands([
+		pagesList, pagesGet, pagesCreate, pagesUpdate, pagesDelete,
+		pagesArchive, pagesUnarchive, pagesLock, pagesUnlock, pagesDuplicate,
+	]),
 );

package/src/config.ts

@@ -179,7 +179,7 @@ export const PageSchema = Schema.Struct({
 	name: Schema.String,
 	description_html: Schema.optional(Schema.NullOr(Schema.String)),
 	created_at: Schema.String,
-	updated_at: Schema.optional(Schema.String),
+	updated_at: Schema.optional(Schema.NullOr(Schema.String)),
 });
 export type Page = typeof PageSchema.Type;
 

package/tests/issue-commands.test.ts

@@ -595,11 +595,11 @@ describe("issueCreate description", () => {
 		);
 
 		expect((postedBody as { description_html?: string }).description_html).toBe(
-			"<p>Some context here</p>",
+			"Some context here",
 		);
 	});
 
-	it("HTML-escapes angle brackets in description", async () => {
+	it("passes raw HTML description as-is", async () => {
 		let postedBody: unknown;
 		server.use(
 			http.post(
@@ -621,10 +621,10 @@ describe("issueCreate description", () => {
 		await Effect.runPromise(
 			issueCreateHandler({
 				project: "ACME",
-				title: "XSS test",
+				title: "HTML test",
 				priority: Option.none(),
 				state: Option.none(),
-				description: Option.some("<script>alert(1)</script>"),
+				description: Option.some("<p>Raw <b>HTML</b></p>"),
 				assignee: Option.none(),
 				label: Option.none(),
 			}),
@@ -632,10 +632,7 @@ describe("issueCreate description", () => {
 
 		expect(
 			(postedBody as { description_html?: string }).description_html,
-		).toContain("&lt;script&gt;");
-		expect(
-			(postedBody as { description_html?: string }).description_html,
-		).not.toContain("<script>");
+		).toBe("<p>Raw <b>HTML</b></p>");
 	});
 });
 
@@ -674,10 +671,10 @@ describe("issueUpdate description", () => {
 
 		expect(
 			(patchedBody as { description_html?: string }).description_html,
-		).toBe("<p>Updated description</p>");
+		).toBe("Updated description");
 	});
 
-	it("HTML-escapes angle brackets in update description", async () => {
+	it("passes raw HTML as-is in update description", async () => {
 		let patchedBody: unknown;
 		server.use(
 			http.patch(
@@ -711,10 +708,7 @@ describe("issueUpdate description", () => {
 
 		expect(
 			(patchedBody as { description_html?: string }).description_html,
-		).toContain("&lt;b&gt;");
-		expect(
-			(patchedBody as { description_html?: string }).description_html,
-		).not.toContain("<b>");
+		).toBe("<b>bold</b>");
 	});
 });
 
@@ -1030,11 +1024,11 @@ describe("--description argv parsing", () => {
 		]);
 		expect(logs.join("\n")).toContain("Created");
 		expect((postedBody as { description_html?: string }).description_html).toBe(
-			"<p>Hello world</p>",
+			"Hello world",
 		);
 	});
 
-	it("issue create HTML-escapes & in description via argv", async () => {
+	it("issue create passes raw HTML description via argv", async () => {
 		let postedBody: unknown;
 		server.use(
 			http.post(
@@ -1056,12 +1050,12 @@ describe("--description argv parsing", () => {
 			"issue",
 			"create",
 			"--description",
-			"a & b",
+			"<p>Raw HTML</p>",
 			"ACME",
-			"Ampersand test",
+			"HTML test",
 		]);
 		expect((postedBody as { description_html?: string }).description_html).toBe(
-			"<p>a &amp; b</p>",
+			"<p>Raw HTML</p>",
 		);
 	});
 
@@ -1086,6 +1080,6 @@ describe("--description argv parsing", () => {
 		await runCli(["issue", "update", "--description", "New desc", "ACME-29"]);
 		expect(
 			(patchedBody as { description_html?: string }).description_html,
-		).toBe("<p>New desc</p>");
+		).toBe("New desc");
 	});
 });

package/tests/pages.test.ts

@@ -7,7 +7,7 @@ import {
 	expect,
 	it,
 } from "bun:test";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 import { http, HttpResponse } from "msw";
 import { setupServer } from "msw/node";
 import { _clearProjectCache } from "@/resolve";
@@ -34,6 +34,14 @@ const PAGES = [
 	},
 ];
 
+const NEW_PAGE = {
+	id: "pg-new",
+	name: "New Page",
+	description_html: null,
+	created_at: "2025-02-01T10:00:00Z",
+	updated_at: "2025-02-01T10:00:00Z",
+};
+
 const server = setupServer(
 	http.get(`${BASE}/api/v1/workspaces/${WS}/projects/`, () =>
 		HttpResponse.json({ results: PROJECTS }),
@@ -136,3 +144,240 @@ describe("pagesGet", () => {
 		expect(parsed.description_html).toContain("architecture");
 	});
 });
+
+describe("pagesCreate", () => {
+	it("creates a page and logs confirmation", async () => {
+		let postedBody: unknown;
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/`,
+				async ({ request }) => {
+					postedBody = await request.json();
+					return HttpResponse.json(NEW_PAGE);
+				},
+			),
+		);
+		const { pagesCreateHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesCreateHandler({
+					project: "ACME",
+					name: "New Page",
+					description: Option.none(),
+				}),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect((postedBody as { name?: string }).name).toBe("New Page");
+		expect(logs.join("\n")).toContain("Created page pg-new");
+	});
+
+	it("sends description_html when provided", async () => {
+		let postedBody: unknown;
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/`,
+				async ({ request }) => {
+					postedBody = await request.json();
+					return HttpResponse.json(NEW_PAGE);
+				},
+			),
+		);
+		const { pagesCreateHandler } = await import("@/commands/pages");
+		await Effect.runPromise(
+			pagesCreateHandler({
+				project: "ACME",
+				name: "New Page",
+				description: Option.some("<p>Hello</p>"),
+			}),
+		);
+		expect((postedBody as { description_html?: string }).description_html).toBe(
+			"<p>Hello</p>",
+		);
+	});
+});
+
+describe("pagesUpdate", () => {
+	it("updates a page name", async () => {
+		let patchedBody: unknown;
+		server.use(
+			http.patch(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/`,
+				async ({ request }) => {
+					patchedBody = await request.json();
+					return HttpResponse.json({ ...PAGES[0], name: "Updated Name" });
+				},
+			),
+		);
+		const { pagesUpdateHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesUpdateHandler({
+					project: "ACME",
+					pageId: "pg1",
+					name: Option.some("Updated Name"),
+					description: Option.none(),
+				}),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect((patchedBody as { name?: string }).name).toBe("Updated Name");
+		expect(logs.join("\n")).toContain("Updated page");
+	});
+
+	it("fails when no options provided", async () => {
+		const { pagesUpdateHandler } = await import("@/commands/pages");
+		await expect(
+			Effect.runPromise(
+				pagesUpdateHandler({
+					project: "ACME",
+					pageId: "pg1",
+					name: Option.none(),
+					description: Option.none(),
+				}),
+			),
+		).rejects.toThrow("provide at least --name or --description");
+	});
+});
+
+describe("pagesDelete", () => {
+	it("deletes a page and logs confirmation", async () => {
+		server.use(
+			http.delete(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/`,
+				() => new HttpResponse(null, { status: 204 }),
+			),
+		);
+		const { pagesDeleteHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesDeleteHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Deleted page pg1");
+	});
+});
+
+describe("pagesArchive / pagesUnarchive", () => {
+	it("archives a page", async () => {
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/archive/`,
+				() => new HttpResponse(null, { status: 204 }),
+			),
+		);
+		const { pagesArchiveHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesArchiveHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Archived page pg1");
+	});
+
+	it("unarchives a page", async () => {
+		server.use(
+			http.delete(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/archive/`,
+				() => new HttpResponse(null, { status: 204 }),
+			),
+		);
+		const { pagesUnarchiveHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesUnarchiveHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Unarchived page pg1");
+	});
+});
+
+describe("pagesLock / pagesUnlock", () => {
+	it("locks a page", async () => {
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/lock/`,
+				() => new HttpResponse(null, { status: 204 }),
+			),
+		);
+		const { pagesLockHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesLockHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Locked page pg1");
+	});
+
+	it("unlocks a page", async () => {
+		server.use(
+			http.delete(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/lock/`,
+				() => new HttpResponse(null, { status: 204 }),
+			),
+		);
+		const { pagesUnlockHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesUnlockHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Unlocked page pg1");
+	});
+});
+
+describe("pagesDuplicate", () => {
+	it("duplicates a page and logs confirmation", async () => {
+		server.use(
+			http.post(
+				`${BASE}/api/v1/workspaces/${WS}/projects/proj-acme/pages/pg1/duplicate/`,
+				() => HttpResponse.json({ ...NEW_PAGE, id: "pg-dup", name: "New Page (copy)" }),
+			),
+		);
+		const { pagesDuplicateHandler } = await import("@/commands/pages");
+		const logs: string[] = [];
+		const orig = console.log;
+		console.log = (...args: unknown[]) => logs.push(args.join(" "));
+		try {
+			await Effect.runPromise(
+				pagesDuplicateHandler({ project: "ACME", pageId: "pg1" }),
+			);
+		} finally {
+			console.log = orig;
+		}
+		expect(logs.join("\n")).toContain("Duplicated page pg-dup");
+	});
+});