@aaronshaf/confluence-cli 0.1.15 → 1.0.1

package/src/cli/index.ts

@@ -16,13 +16,14 @@ import {
   showLabelsHelp,
   showMoveHelp,
   showOpenHelp,
+  showFolderHelp,
   showPullHelp,
-  showPushHelp,
   showSearchHelp,
   showSetupHelp,
   showSpacesHelp,
   showStatusHelp,
   showTreeHelp,
+  showUpdateHelp,
 } from './help.js';
 import { attachmentsCommand } from './commands/attachments.js';
 import { cloneCommand } from './commands/clone.js';
@@ -34,13 +35,16 @@ import { infoCommand } from './commands/info.js';
 import { labelsCommand } from './commands/labels.js';
 import { moveCommand } from './commands/move.js';
 import { openCommand } from './commands/open.js';
+import { folderCommand } from './commands/folder.js';
 import { pullCommand } from './commands/pull.js';
-import { pushCommand } from './commands/push.js';
 import { searchCommand } from './commands/search.js';
 import { setup } from './commands/setup.js';
 import { spacesCommand } from './commands/spaces.js';
 import { statusCommand } from './commands/status.js';
 import { treeCommand } from './commands/tree.js';
+import { updateCommand } from './commands/update.js';
+
+import { findPositional } from './utils/args.js';
 
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -128,20 +132,18 @@ async function main(): Promise<void> {
         break;
       }
 
-      case 'push': {
-        if (args.includes('--help')) {
-          showPushHelp();
+      case 'folder': {
+        if (args.includes('--help') && !subArgs.find((a) => !a.startsWith('--'))) {
+          showFolderHelp();
           process.exit(EXIT_CODES.SUCCESS);
         }
-
-        // File is optional - if not provided, scan for changes
-        const file = subArgs.find((arg) => !arg.startsWith('--'));
-
-        await pushCommand({
-          file,
-          force: args.includes('--force'),
-          dryRun: args.includes('--dry-run'),
-        });
+        const folderSubcommand = subArgs[0];
+        if (!folderSubcommand || folderSubcommand.startsWith('--')) {
+          showFolderHelp();
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        const folderSubArgs = subArgs.slice(1);
+        await folderCommand(folderSubcommand, folderSubArgs, args);
         break;
       }
 
@@ -212,7 +214,23 @@ async function main(): Promise<void> {
           showSpacesHelp();
           process.exit(EXIT_CODES.SUCCESS);
         }
-        await spacesCommand({ xml: args.includes('--xml') });
+        {
+          let limit: number | undefined;
+          const limitArg = args.find((a) => a.startsWith('--limit=') || a === '--limit');
+          if (limitArg) {
+            limit = limitArg.includes('=')
+              ? Number.parseInt(limitArg.split('=')[1], 10)
+              : Number.parseInt(args[args.indexOf('--limit') + 1], 10);
+          }
+          let page: number | undefined;
+          const pageArg = args.find((a) => a.startsWith('--page=') || a === '--page');
+          if (pageArg) {
+            page = pageArg.includes('=')
+              ? Number.parseInt(pageArg.split('=')[1], 10)
+              : Number.parseInt(args[args.indexOf('--page') + 1], 10);
+          }
+          await spacesCommand({ xml: args.includes('--xml'), limit, page });
+        }
         break;
 
       case 'search': {
@@ -273,8 +291,12 @@ async function main(): Promise<void> {
         if (parentIdx !== -1 && parentIdx + 1 < args.length) {
           parentId = args[parentIdx + 1];
         }
-        const createFlagValues = new Set([spaceKey, parentId].filter(Boolean));
-        const title = subArgs.find((arg) => !arg.startsWith('--') && !createFlagValues.has(arg));
+        let createFormat: string | undefined;
+        const createFormatIdx = args.indexOf('--format');
+        if (createFormatIdx !== -1 && createFormatIdx + 1 < args.length) {
+          createFormat = args[createFormatIdx + 1];
+        }
+        const title = findPositional(subArgs, ['--space', '--parent', '--format']);
         if (!title) {
           console.error(chalk.red('Page title is required.'));
           console.log(chalk.gray('Usage: cn create <title>'));
@@ -284,6 +306,7 @@ async function main(): Promise<void> {
           space: spaceKey,
           parent: parentId,
           open: args.includes('--open'),
+          format: createFormat,
         });
         break;
       }
@@ -395,6 +418,40 @@ async function main(): Promise<void> {
         break;
       }
 
+      case 'update': {
+        if (args.includes('--help')) {
+          showUpdateHelp();
+          process.exit(EXIT_CODES.SUCCESS);
+        }
+        let updateFormat: string | undefined;
+        const updateFormatIdx = args.indexOf('--format');
+        if (updateFormatIdx !== -1 && updateFormatIdx + 1 < args.length) {
+          updateFormat = args[updateFormatIdx + 1];
+        }
+        let updateTitle: string | undefined;
+        const updateTitleIdx = args.indexOf('--title');
+        if (updateTitleIdx !== -1 && updateTitleIdx + 1 < args.length) {
+          updateTitle = args[updateTitleIdx + 1];
+        }
+        let updateMessage: string | undefined;
+        const updateMessageIdx = args.indexOf('--message');
+        if (updateMessageIdx !== -1 && updateMessageIdx + 1 < args.length) {
+          updateMessage = args[updateMessageIdx + 1];
+        }
+        const updateId = findPositional(subArgs, ['--format', '--title', '--message']);
+        if (!updateId) {
+          console.error(chalk.red('Page ID is required.'));
+          console.log(chalk.gray('Usage: cn update <id>'));
+          process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        await updateCommand(updateId, {
+          format: updateFormat,
+          title: updateTitle,
+          message: updateMessage,
+        });
+        break;
+      }
+
       default:
         console.error(`Unknown command: ${command}`);
         console.log('Run "cn help" for usage information');

package/src/cli/utils/args.ts

@@ -0,0 +1,15 @@
+/**
+ * Find a positional argument in args, skipping flags and their values.
+ * --flag <value> pairs are identified by their indices so we never mistake
+ * a flag's value for a positional argument even if they are equal strings.
+ */
+export function findPositional(args: string[], flagsWithValues: string[]): string | undefined {
+  const flagValueIndices = new Set<number>();
+  for (const flag of flagsWithValues) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && idx + 1 < args.length) {
+      flagValueIndices.add(idx + 1);
+    }
+  }
+  return args.find((arg, i) => !arg.startsWith('--') && !flagValueIndices.has(i));
+}

package/src/cli/utils/stdin.ts

@@ -0,0 +1,14 @@
+export async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+export const VALID_FORMATS = ['storage', 'wiki', 'atlas_doc_format'] as const;
+export type ValidFormat = (typeof VALID_FORMATS)[number];
+
+export function isValidFormat(s: string): s is ValidFormat {
+  return (VALID_FORMATS as readonly string[]).includes(s);
+}

package/src/lib/confluence-client/client.ts

@@ -7,11 +7,12 @@ import {
   NetworkError,
   type PageNotFoundError,
   RateLimitError,
-  SpaceNotFoundError,
+  type SpaceNotFoundError,
   type VersionConflictError,
 } from '../errors.js';
 import {
   createFolderEffect as createFolderEffectFn,
+  deleteFolderEffect as deleteFolderEffectFn,
   findFolderByTitle as findFolderByTitleFn,
   getFolderEffect as getFolderEffectFn,
   movePageEffect as movePageEffectFn,
@@ -33,13 +34,20 @@ import {
 import { searchEffect as searchEffectFn } from './search-operations.js';
 import { getAllFooterComments as getAllFooterCommentsFn } from './comment-operations.js';
 import { getUserEffect as getUserEffectFn } from './user-operations.js';
+import {
+  getAllSpaces as getAllSpacesFn,
+  getSpaces as getSpacesFn,
+  getSpacesEffect as getSpacesEffectFn,
+  getSpaceByKey as getSpaceByKeyFn,
+  getSpaceByKeyEffect as getSpaceByKeyEffectFn,
+  getSpaceByIdEffect as getSpaceByIdEffectFn,
+} from './space-operations.js';
 import {
   CommentsResponseSchema,
   FolderSchema,
   LabelsResponseSchema,
   PageSchema,
   PagesResponseSchema,
-  SpaceSchema,
   SpacesResponseSchema,
   type Attachment,
   type AttachmentsResponse,
@@ -108,8 +116,10 @@ export class ConfluenceClient {
   ): Effect.Effect<T, ApiError | AuthError | NetworkError | RateLimitError> {
     const url = `${this.baseUrl}/wiki/api/v2${path}`;
 
+    const verbose = process.env.CN_DEBUG === '1';
     const makeRequest = Effect.tryPromise({
       try: async () => {
+        if (verbose) process.stderr.write(`[debug] fetch: ${url}\n`);
         const response = await fetch(url, {
           ...options,
           headers: {
@@ -169,74 +179,36 @@ export class ConfluenceClient {
 
   /** Get all spaces (Effect version) */
   getSpacesEffect(limit = 25): Effect.Effect<SpacesResponse, ApiError | AuthError | NetworkError | RateLimitError> {
-    return this.fetchWithRetryEffect(`/spaces?limit=${limit}`, SpacesResponseSchema);
+    return getSpacesEffectFn(this.baseUrl, this.authHeader, limit, (path, schema) =>
+      this.fetchWithRetryEffect(path, schema),
+    );
   }
 
-  /** Get all spaces (async version) */
-  async getSpaces(limit = 25): Promise<SpacesResponse> {
-    return this.fetchWithRetry(`/spaces?limit=${limit}`, SpacesResponseSchema);
+  /** Get spaces with offset-based pagination via v1 API */
+  async getSpaces(limit = 25, page = 1): Promise<{ results: Space[]; start: number; limit: number; size: number }> {
+    return getSpacesFn(this.baseUrl, this.authHeader, limit, page);
   }
 
-  /** Get all spaces with pagination (async version) */
+  /** Get all spaces with full cursor pagination */
   async getAllSpaces(): Promise<Space[]> {
-    const allSpaces: Space[] = [];
-    let cursor: string | undefined;
-    do {
-      let path = '/spaces?limit=100';
-      if (cursor) path += `&cursor=${encodeURIComponent(cursor)}`;
-      const response = await this.fetchWithRetry(path, SpacesResponseSchema);
-      allSpaces.push(...response.results);
-      cursor = extractCursor(response._links?.next);
-    } while (cursor);
-    return allSpaces;
+    return getAllSpacesFn(this.baseUrl, this.authHeader, (path, schema) => this.fetchWithRetry(path, schema));
   }
 
   /** Get a space by key (Effect version) */
   getSpaceByKeyEffect(
     key: string,
   ): Effect.Effect<Space, ApiError | AuthError | NetworkError | RateLimitError | SpaceNotFoundError> {
-    return pipe(
-      this.fetchWithRetryEffect(`/spaces?keys=${key}&limit=1`, SpacesResponseSchema),
-      Effect.flatMap((response) => {
-        if (response.results.length === 0) {
-          return Effect.fail(new SpaceNotFoundError(key));
-        }
-        return Effect.succeed(response.results[0]);
-      }),
-    );
+    return getSpaceByKeyEffectFn(key, (path, schema) => this.fetchWithRetryEffect(path, schema));
   }
 
   /** Get a space by key (async version) */
   async getSpaceByKey(key: string): Promise<Space> {
-    const response = await this.fetchWithRetry(`/spaces?keys=${key}&limit=1`, SpacesResponseSchema);
-    if (response.results.length === 0) {
-      throw new SpaceNotFoundError(key);
-    }
-    return response.results[0];
+    return getSpaceByKeyFn(key, (path, schema) => this.fetchWithRetry(path, schema));
   }
 
   /** Get a space by ID (Effect version) */
-  getSpaceByIdEffect(
-    id: string,
-  ): Effect.Effect<Space, ApiError | AuthError | NetworkError | RateLimitError | SpaceNotFoundError> {
-    const baseUrl = this.baseUrl;
-    const authHeader = this.authHeader;
-    return Effect.tryPromise({
-      try: async () => {
-        const url = `${baseUrl}/wiki/api/v2/spaces/${id}`;
-        const response = await fetch(url, { headers: { Authorization: authHeader, Accept: 'application/json' } });
-        if (response.status === 404) throw new SpaceNotFoundError(id);
-        if (response.status === 401) throw new AuthError('Invalid credentials', 401);
-        if (response.status === 403) throw new AuthError('Access denied', 403);
-        if (!response.ok) throw new ApiError(`API error: ${response.status}`, response.status);
-        return Schema.decodeUnknownSync(SpaceSchema)(await response.json());
-      },
-      catch: (error) => {
-        if (error instanceof SpaceNotFoundError || error instanceof AuthError || error instanceof ApiError)
-          return error;
-        return new NetworkError(`Network error: ${error}`);
-      },
-    });
+  getSpaceByIdEffect(id: string): Effect.Effect<Space, ApiError | AuthError | NetworkError | SpaceNotFoundError> {
+    return getSpaceByIdEffectFn(id, this.baseUrl, this.authHeader);
   }
 
   /** Get a space by ID (async version) */
@@ -479,6 +451,20 @@ export class ConfluenceClient {
     return Effect.runPromise(this.createFolderEffect(request));
   }
 
+  /**
+   * Delete a folder by ID (Effect version)
+   */
+  deleteFolderEffect(
+    folderId: string,
+  ): Effect.Effect<void, ApiError | AuthError | NetworkError | RateLimitError | FolderNotFoundError> {
+    return deleteFolderEffectFn(this.baseUrl, this.authHeader, folderId);
+  }
+
+  /** Delete a folder by ID (async version) */
+  async deleteFolder(folderId: string): Promise<void> {
+    return Effect.runPromise(this.deleteFolderEffect(folderId));
+  }
+
   /**
    * Find a folder by title in a space
    * Uses v1 CQL search API to find folders by title
@@ -514,13 +500,14 @@ export class ConfluenceClient {
   searchEffect(
     cql: string,
     limit = 10,
+    start = 0,
   ): Effect.Effect<SearchResponse, ApiError | AuthError | NetworkError | RateLimitError> {
-    return searchEffectFn(this.baseUrl, this.authHeader, cql, limit);
+    return searchEffectFn(this.baseUrl, this.authHeader, cql, limit, start);
   }
 
   /** Search pages using CQL (async version) */
-  async search(cql: string, limit = 10): Promise<SearchResponse> {
-    return Effect.runPromise(this.searchEffect(cql, limit));
+  async search(cql: string, limit = 10, start = 0): Promise<SearchResponse> {
+    return Effect.runPromise(this.searchEffect(cql, limit, start));
   }
 
   // ================== Comments API ==================

package/src/lib/confluence-client/folder-operations.ts

@@ -118,6 +118,47 @@ export function createFolderEffect(
   );
 }
 
+/**
+ * Delete a folder by ID (Effect version)
+ */
+export function deleteFolderEffect(
+  baseUrl: string,
+  authHeader: string,
+  folderId: string,
+): Effect.Effect<void, ApiError | AuthError | NetworkError | RateLimitError | FolderNotFoundError> {
+  const makeRequest = Effect.tryPromise({
+    try: async () => {
+      const url = `${baseUrl}/wiki/api/v2/folders/${folderId}`;
+      const response = await fetch(url, {
+        method: 'DELETE',
+        headers: { Authorization: authHeader, Accept: 'application/json' },
+      });
+
+      if (response.status === 404) throw new FolderNotFoundError(folderId);
+      if (response.status === 401) throw new AuthError('Invalid credentials', 401);
+      if (response.status === 403) throw new AuthError('Access denied', 403);
+      if (response.status === 429) {
+        const retryAfter = response.headers.get('Retry-After');
+        throw new RateLimitError('Rate limited', retryAfter ? Number.parseInt(retryAfter, 10) : undefined);
+      }
+      if (!response.ok) throw new ApiError(`API error: ${response.status}`, response.status);
+    },
+    catch: (error) => {
+      if (
+        error instanceof FolderNotFoundError ||
+        error instanceof AuthError ||
+        error instanceof ApiError ||
+        error instanceof RateLimitError
+      ) {
+        return error;
+      }
+      return new NetworkError(`Network error: ${error}`);
+    },
+  });
+
+  return pipe(makeRequest, Effect.retry(rateLimitRetrySchedule));
+}
+
 /**
  * Move a page to a new parent (Effect version)
  * Uses v1 API: PUT /wiki/rest/api/content/{id}/move/{position}/{targetId}

package/src/lib/confluence-client/index.ts

@@ -19,6 +19,7 @@ export type {
   SearchResultItem,
   Space,
   SpacesResponse,
+  SpacesV1Response,
   UpdatePageRequest,
   User,
   Version,

package/src/lib/confluence-client/search-operations.ts

@@ -21,8 +21,9 @@ export function searchEffect(
   authHeader: string,
   cql: string,
   limit = 10,
+  start = 0,
 ): Effect.Effect<SearchResponse, ApiError | AuthError | NetworkError | RateLimitError> {
-  const url = `${baseUrl}/wiki/rest/api/search?cql=${encodeURIComponent(cql)}&limit=${limit}`;
+  const url = `${baseUrl}/wiki/rest/api/search?cql=${encodeURIComponent(cql)}&limit=${limit}&start=${start}`;
 
   const makeRequest = Effect.tryPromise({
     try: async () => {

package/src/lib/confluence-client/space-operations.ts

@@ -0,0 +1,133 @@
+import { Effect, pipe, Schema } from 'effect';
+import { ApiError, AuthError, NetworkError, type RateLimitError, SpaceNotFoundError } from '../errors.js';
+import { SpaceSchema, SpacesResponseSchema, SpacesV1ResponseSchema, type Space, type SpacesResponse } from './types.js';
+
+function extractCursor(nextLink: string | undefined): string | undefined {
+  if (!nextLink) return undefined;
+  try {
+    const url = new URL(nextLink, 'https://placeholder.invalid');
+    return url.searchParams.get('cursor') ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function fetchV1<T>(baseUrl: string, authHeader: string, path: string, schema: Schema.Schema<T>): Promise<T> {
+  const url = `${baseUrl}/wiki/rest/api${path}`;
+  const verbose = process.env.CN_DEBUG === '1';
+  if (verbose) process.stderr.write(`[debug] fetchV1: ${url}\n`);
+  const response = await fetch(url, {
+    headers: { Authorization: authHeader, Accept: 'application/json' },
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new ApiError(`API request failed: ${response.status} ${errorText}`, response.status);
+  }
+  const data = await response.json();
+  return Effect.runPromise(
+    Schema.decodeUnknown(schema)(data).pipe(Effect.mapError((e) => new ApiError(`Invalid response: ${e}`, 500))),
+  );
+}
+
+export function getSpacesEffect(
+  _baseUrl: string,
+  _authHeader: string,
+  limit: number,
+  fetchWithRetryEffect: <T>(
+    path: string,
+    schema: Schema.Schema<T>,
+  ) => Effect.Effect<T, ApiError | AuthError | NetworkError | RateLimitError>,
+): Effect.Effect<SpacesResponse, ApiError | AuthError | NetworkError | RateLimitError> {
+  return fetchWithRetryEffect(`/spaces?limit=${limit}`, SpacesResponseSchema);
+}
+
+export async function getSpaces(
+  baseUrl: string,
+  authHeader: string,
+  limit = 25,
+  page = 1,
+): Promise<{ results: Space[]; start: number; limit: number; size: number }> {
+  const start = (page - 1) * limit;
+  const response = await fetchV1(baseUrl, authHeader, `/space?limit=${limit}&start=${start}`, SpacesV1ResponseSchema);
+  return {
+    ...response,
+    results: response.results.map((s) => ({ ...s, id: String(s.id) })),
+  };
+}
+
+export async function getAllSpaces(
+  baseUrl: string,
+  _authHeader: string,
+  fetchWithRetry: <T>(path: string, schema: Schema.Schema<T>) => Promise<T>,
+): Promise<Space[]> {
+  const verbose = process.env.CN_DEBUG === '1';
+  const allSpaces: Space[] = [];
+  let cursor: string | undefined;
+  let page = 1;
+  do {
+    let path = '/spaces?limit=20';
+    if (cursor) path += `&cursor=${encodeURIComponent(cursor)}`;
+    if (verbose) process.stderr.write(`[debug] getAllSpaces: fetching page ${page} (${baseUrl}/wiki/api/v2${path})\n`);
+    const response = await fetchWithRetry(path, SpacesResponseSchema);
+    if (verbose)
+      process.stderr.write(
+        `[debug] getAllSpaces: got ${response.results.length} spaces, next=${response._links?.next ?? 'none'}\n`,
+      );
+    allSpaces.push(...response.results);
+    cursor = extractCursor(response._links?.next);
+    page++;
+  } while (cursor);
+  if (verbose) process.stderr.write(`[debug] getAllSpaces: done, total=${allSpaces.length}\n`);
+  return allSpaces;
+}
+
+export function getSpaceByKeyEffect(
+  key: string,
+  fetchWithRetryEffect: <T>(
+    path: string,
+    schema: Schema.Schema<T>,
+  ) => Effect.Effect<T, ApiError | AuthError | NetworkError | RateLimitError>,
+): Effect.Effect<Space, ApiError | AuthError | NetworkError | RateLimitError | SpaceNotFoundError> {
+  return pipe(
+    fetchWithRetryEffect(`/spaces?keys=${key}&limit=1`, SpacesResponseSchema),
+    Effect.flatMap((response) => {
+      if (response.results.length === 0) {
+        return Effect.fail(new SpaceNotFoundError(key));
+      }
+      return Effect.succeed(response.results[0]);
+    }),
+  );
+}
+
+export async function getSpaceByKey(
+  key: string,
+  fetchWithRetry: <T>(path: string, schema: Schema.Schema<T>) => Promise<T>,
+): Promise<Space> {
+  const response = await fetchWithRetry(`/spaces?keys=${key}&limit=1`, SpacesResponseSchema);
+  if (response.results.length === 0) {
+    throw new SpaceNotFoundError(key);
+  }
+  return response.results[0];
+}
+
+export function getSpaceByIdEffect(
+  id: string,
+  baseUrl: string,
+  authHeader: string,
+): Effect.Effect<Space, ApiError | AuthError | NetworkError | SpaceNotFoundError> {
+  return Effect.tryPromise({
+    try: async () => {
+      const url = `${baseUrl}/wiki/api/v2/spaces/${id}`;
+      const response = await fetch(url, { headers: { Authorization: authHeader, Accept: 'application/json' } });
+      if (response.status === 404) throw new SpaceNotFoundError(id);
+      if (response.status === 401) throw new AuthError('Invalid credentials', 401);
+      if (response.status === 403) throw new AuthError('Access denied', 403);
+      if (!response.ok) throw new ApiError(`API error: ${response.status}`, response.status);
+      return Schema.decodeUnknownSync(SpaceSchema)(await response.json());
+    },
+    catch: (error) => {
+      if (error instanceof SpaceNotFoundError || error instanceof AuthError || error instanceof ApiError) return error;
+      return new NetworkError(`Network error: ${error}`);
+    },
+  });
+}

package/src/lib/confluence-client/types.ts

@@ -24,7 +24,7 @@ export const SpaceSchema = Schema.Struct({
   name: Schema.String,
   type: Schema.optional(Schema.String),
   status: Schema.optional(Schema.String),
-  homepageId: Schema.optional(Schema.String),
+  homepageId: Schema.optional(Schema.NullOr(Schema.String)),
   description: Schema.optional(
     Schema.NullOr(
       Schema.Struct({
@@ -57,6 +57,23 @@ export const SpacesResponseSchema = Schema.Struct({
 });
 export type SpacesResponse = Schema.Schema.Type<typeof SpacesResponseSchema>;
 
+const SpaceV1Schema = Schema.Struct({
+  id: Schema.Number,
+  key: Schema.String,
+  name: Schema.String,
+  type: Schema.optional(Schema.String),
+  status: Schema.optional(Schema.String),
+  _links: Schema.optional(Schema.Struct({ webui: Schema.optional(Schema.String) })),
+});
+
+export const SpacesV1ResponseSchema = Schema.Struct({
+  results: Schema.Array(SpaceV1Schema),
+  start: Schema.Number,
+  limit: Schema.Number,
+  size: Schema.Number,
+});
+export type SpacesV1Response = Schema.Schema.Type<typeof SpacesV1ResponseSchema>;
+
 /**
  * Page version information
  */
@@ -182,12 +199,19 @@ export interface VersionConflictResponse {
 /**
  * Request body for updating a page
  */
+export const RepresentationSchema = Schema.Union(
+  Schema.Literal('storage'),
+  Schema.Literal('wiki'),
+  Schema.Literal('atlas_doc_format'),
+);
+export type Representation = Schema.Schema.Type<typeof RepresentationSchema>;
+
 export const UpdatePageRequestSchema = Schema.Struct({
   id: Schema.String,
   status: Schema.String,
   title: Schema.String,
   body: Schema.Struct({
-    representation: Schema.Literal('storage'),
+    representation: RepresentationSchema,
     value: Schema.String,
   }),
   version: Schema.Struct({
@@ -206,7 +230,7 @@ export const CreatePageRequestSchema = Schema.Struct({
   title: Schema.String,
   parentId: Schema.optional(Schema.String),
   body: Schema.Struct({
-    representation: Schema.Literal('storage'),
+    representation: RepresentationSchema,
     value: Schema.String,
   }),
 });

package/src/test/confluence-client.test.ts

@@ -23,7 +23,7 @@ describe('ConfluenceClient', () => {
 
     test('throws AuthError on 401', async () => {
       server.use(
-        http.get('*/wiki/api/v2/spaces', () => {
+        http.get('*/wiki/rest/api/space', () => {
           return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
         }),
       );
@@ -37,7 +37,7 @@ describe('ConfluenceClient', () => {
 
     test('throws AuthError on 403', async () => {
       server.use(
-        http.get('*/wiki/api/v2/spaces', () => {
+        http.get('*/wiki/rest/api/space', () => {
           return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
         }),
       );
@@ -63,16 +63,18 @@ describe('ConfluenceClient', () => {
 
     test('handles spaces with null description', async () => {
       server.use(
-        http.get('*/wiki/api/v2/spaces', () => {
+        http.get('*/wiki/rest/api/space', () => {
           return HttpResponse.json({
             results: [
               {
-                id: 'space-null-desc',
+                id: 99,
                 key: 'NULL',
                 name: 'Space with null description',
-                description: null,
               },
             ],
+            start: 0,
+            limit: 25,
+            size: 1,
           });
         }),
       );
@@ -82,7 +84,6 @@ describe('ConfluenceClient', () => {
 
       expect(response.results).toBeArray();
       expect(response.results[0].key).toBe('NULL');
-      expect(response.results[0].description).toBeNull();
     });
   });
 
@@ -425,7 +426,8 @@ describe('ConfluenceClient', () => {
       );
 
       const client = new ConfluenceClient(testConfig);
-      const response = await client.getSpaces();
+      const { Effect } = await import('effect');
+      const response = await Effect.runPromise(client.getSpacesEffect(1));
 
       expect(response.results).toBeArray();
       expect(requestCount).toBe(2);