@kitae9999/openlog-cli 0.1.0 → 0.2.0

package/README.md

@@ -8,6 +8,17 @@ npx -y @kitae9999/openlog-cli whoami
 npx -y @kitae9999/openlog-cli mcp
 ```
 
+MCP tools:
+
+- `get_auth_status`
+- `get_me`
+- `list_my_notifications`
+- `list_my_posts`
+- `list_my_liked_posts`
+- `upload_post_image`
+- `publish_post`
+- `get_post_detail`
+
 MCP client configuration:
 
 ```json
@@ -21,4 +32,5 @@ MCP client configuration:
 }
 ```
 
-Set `OPENLOG_API_BASE_URL` to point at a non-production API.
+Set `OPENLOG_API_BASE_URL` to point at a non-production API. Set
+`OPENLOG_WEB_BASE_URL` to control absolute post URLs returned by `publish_post`.

package/dist/api-client.js

@@ -33,6 +33,13 @@ export class OpenLogApiClient {
             body: body ? JSON.stringify(body) : undefined,
         });
     }
+    async patchNoContent(path, body) {
+        await this.request(path, {
+            method: "PATCH",
+            headers: body ? { "content-type": "application/json" } : undefined,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
     async request(path, init) {
         const url = `${this.apiBaseUrl}${path}`;
         const response = await fetch(url, {

package/dist/config.js

@@ -1,9 +1,13 @@
 import os from "node:os";
 import path from "node:path";
 export const DEFAULT_API_BASE_URL = "https://api.openlog.kr/api";
+export const DEFAULT_WEB_BASE_URL = "https://openlog.kr";
 export function getApiBaseUrl() {
     return (process.env.OPENLOG_API_BASE_URL ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
 }
+export function getWebBaseUrl() {
+    return (process.env.OPENLOG_WEB_BASE_URL ?? DEFAULT_WEB_BASE_URL).replace(/\/$/, "");
+}
 export function getAuthFilePath() {
     return (process.env.OPENLOG_AUTH_FILE ??
         path.join(os.homedir(), ".openlog", "auth.json"));

package/dist/index.js

@@ -90,7 +90,10 @@ Available tools:
   get_auth_status
   get_me
   list_my_notifications
+  list_my_posts
   list_my_liked_posts
+  upload_post_image
+  publish_post
   get_post_detail
 `);
 }
@@ -109,6 +112,7 @@ Usage:
 
 Environment:
   OPENLOG_API_BASE_URL  Override the OpenLog API base URL
+  OPENLOG_WEB_BASE_URL  Override the OpenLog web base URL for published post links
   OPENLOG_AUTH_FILE     Override the local auth file path
 `);
 }

package/dist/mcp-install.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { DEFAULT_API_BASE_URL, getApiBaseUrl } from "./config.js";
+import { DEFAULT_API_BASE_URL, DEFAULT_WEB_BASE_URL, getApiBaseUrl, getWebBaseUrl, } from "./config.js";
 export async function installMcp(options) {
     const serverConfig = buildServerConfig();
     if (options.printOnly) {
@@ -28,15 +28,19 @@ Aliases:
   claude      Same as claude-code
 
 Notes:
-  If OPENLOG_API_BASE_URL is set, it is added to the client config.
+  If OPENLOG_API_BASE_URL or OPENLOG_WEB_BASE_URL is set, it is added to the client config.
 `);
 }
 function buildServerConfig() {
     const apiBaseUrl = getApiBaseUrl();
+    const webBaseUrl = getWebBaseUrl();
     const env = {};
     if (apiBaseUrl !== DEFAULT_API_BASE_URL) {
         env.OPENLOG_API_BASE_URL = apiBaseUrl;
     }
+    if (webBaseUrl !== DEFAULT_WEB_BASE_URL) {
+        env.OPENLOG_WEB_BASE_URL = webBaseUrl;
+    }
     return {
         command: "openlog",
         args: ["mcp"],

package/dist/mcp-server.js

@@ -3,11 +3,18 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { OpenLogApiClient } from "./api-client.js";
 import { readAuthFile } from "./auth-store.js";
-import { getApiBaseUrl } from "./config.js";
+import { getApiBaseUrl, getWebBaseUrl } from "./config.js";
+import { uploadPostImage } from "./post-image-upload.js";
+const WRITE_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true,
+};
 export async function runMcpServer() {
     const server = new McpServer({
         name: "openlog",
-        version: "0.1.0",
+        version: "0.2.0",
     });
     server.registerTool("get_auth_status", {
         title: "Get OpenLog Auth Status",
@@ -65,6 +72,87 @@ export async function runMcpServer() {
         }
         return withAuthenticatedClient((client) => client.get(`/users/me/liked-posts?${params}`));
     });
+    server.registerTool("list_my_posts", {
+        title: "List My OpenLog Posts",
+        description: "Return posts authored by the authenticated OpenLog user.",
+        inputSchema: {
+            size: z.number().int().min(1).max(100).default(20),
+        },
+    }, async ({ size }) => withAuthenticatedClient(async (client) => {
+        const me = await client.get("/auth/me");
+        const username = me.username?.trim();
+        if (!username) {
+            throw new Error("Complete OpenLog onboarding before listing your posts.");
+        }
+        const posts = await client.get(`/users/${encodeURIComponent(username)}/posts`);
+        return {
+            username,
+            total: posts.length,
+            size,
+            hasMore: posts.length > size,
+            posts: posts.slice(0, size),
+        };
+    }));
+    server.registerTool("upload_post_image", {
+        title: "Upload OpenLog Post Image",
+        description: "Convert a local image file to WebP, upload it to OpenLog, and return markdown for post content.",
+        annotations: WRITE_TOOL_ANNOTATIONS,
+        inputSchema: {
+            filePath: z.string().min(1),
+            altText: z.string().optional(),
+        },
+    }, async ({ filePath, altText }) => withAuthenticatedClient((client) => uploadPostImage(client, {
+        filePath,
+        altText,
+    })));
+    server.registerTool("publish_post", {
+        title: "Publish OpenLog Post",
+        description: "Publish a new post to the authenticated OpenLog account. Requires confirm: true unless skipConfirmation: true is explicitly provided.",
+        annotations: WRITE_TOOL_ANNOTATIONS,
+        inputSchema: {
+            title: z.string().min(1),
+            description: z.string().min(1),
+            content: z.string().min(1),
+            topics: z.array(z.string()).default([]),
+            links: z
+                .array(z.object({
+                label: z.string().min(1),
+                targetSlug: z.string().min(1),
+            }))
+                .default([]),
+            confirm: z.boolean().optional(),
+            skipConfirmation: z.boolean().optional(),
+        },
+    }, async ({ title, description, content, topics, links, confirm, skipConfirmation, }) => withAuthenticatedClient(async (client) => {
+        const post = normalizePostInput({
+            title,
+            description,
+            content,
+            topics,
+            links,
+        });
+        if (confirm !== true && skipConfirmation !== true) {
+            return {
+                requiresConfirmation: true,
+                preview: {
+                    title: post.title,
+                    description: post.description,
+                    contentPreview: createContentPreview(post.content),
+                    contentLength: post.content.length,
+                    topics: post.topics,
+                    links: post.links,
+                },
+                nextStep: "Call publish_post again with confirm: true, or skipConfirmation: true if the user explicitly requested publishing without confirmation.",
+            };
+        }
+        const published = await client.post("/posts", post);
+        const postPath = buildPublicPostPath(published.authorUsername, published.slug);
+        return {
+            ...published,
+            path: postPath,
+            url: new URL(postPath, `${getWebBaseUrl()}/`).toString(),
+        };
+    }));
     server.registerTool("get_post_detail", {
         title: "Get OpenLog Post Detail",
         description: "Return a public OpenLog post detail by author username and post slug.",
@@ -75,6 +163,55 @@ export async function runMcpServer() {
     }, async ({ username, slug }) => withAuthenticatedClient((client) => client.get(`/users/${encodeURIComponent(username)}/posts/${encodeURIComponent(slug)}`)));
     await server.connect(new StdioServerTransport());
 }
+function normalizePostInput(input) {
+    const title = input.title.trim();
+    const description = input.description.trim();
+    const content = input.content.trim();
+    if (!title) {
+        throw new Error("title is required.");
+    }
+    if (!description) {
+        throw new Error("description is required.");
+    }
+    if (!content) {
+        throw new Error("content is required.");
+    }
+    return {
+        title,
+        description,
+        content,
+        topics: normalizeTopics(input.topics),
+        links: normalizeLinks(input.links),
+    };
+}
+function normalizeTopics(topics) {
+    const normalized = topics
+        .map((topic) => topic.trim().toLowerCase())
+        .filter(Boolean);
+    return [...new Set(normalized)];
+}
+function normalizeLinks(links) {
+    const normalized = [];
+    const seen = new Set();
+    for (const link of links) {
+        const label = link.label.trim();
+        const targetSlug = link.targetSlug.trim();
+        const key = `${label}\u0000${targetSlug}`;
+        if (!label || !targetSlug || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        normalized.push({ label, targetSlug });
+    }
+    return normalized;
+}
+function createContentPreview(content) {
+    const preview = content.replace(/\s+/g, " ").trim();
+    return preview.length > 500 ? `${preview.slice(0, 497)}...` : preview;
+}
+function buildPublicPostPath(username, slug) {
+    return `/@${encodeURIComponent(username)}/posts/${encodeURIComponent(slug)}`;
+}
 async function createAuthenticatedClient() {
     const authFile = await readAuthFile();
     if (!authFile) {

package/dist/post-image-upload.js

@@ -0,0 +1,137 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import sharp from "sharp";
+const MAX_POST_IMAGE_WIDTH = 1600;
+const MAX_WEBP_BYTES = 10 * 1024 * 1024;
+const WEBP_QUALITY = 84;
+export async function uploadPostImage(client, { filePath, altText, }) {
+    const resolvedPath = resolveLocalPath(filePath);
+    const originalFileName = path.basename(resolvedPath);
+    const resolvedAltText = normalizeAltText(altText, originalFileName);
+    await assertReadableFile(resolvedPath);
+    const webp = await createWebpPostImage(resolvedPath);
+    if (webp.byteLength > MAX_WEBP_BYTES) {
+        throw new Error("Converted image must be 10 MB or smaller.");
+    }
+    const uploadTarget = await client.post("/media/upload-url", {
+        fileName: `${sanitizeFileStem(resolvedAltText)}.webp`,
+        originalFileName,
+        contentType: "image/webp",
+        sizeBytes: webp.byteLength,
+        purpose: "POST_BODY_IMAGE",
+    });
+    await putImage(uploadTarget, webp);
+    const assetId = String(uploadTarget.assetId);
+    await client.patchNoContent(`/media/assets/${encodeURIComponent(assetId)}/completion`);
+    const markdownUrl = getMarkdownUrl(uploadTarget);
+    if (!markdownUrl) {
+        throw new Error("Upload completed without a markdown image URL.");
+    }
+    return {
+        assetId,
+        markdownUrl,
+        markdown: `![${escapeMarkdownAltText(resolvedAltText)}](${markdownUrl})`,
+        altText: resolvedAltText,
+        originalFileName,
+        webpSizeBytes: webp.byteLength,
+    };
+}
+function resolveLocalPath(filePath) {
+    const trimmedPath = filePath.trim();
+    if (!trimmedPath) {
+        throw new Error("filePath is required.");
+    }
+    return path.isAbsolute(trimmedPath)
+        ? trimmedPath
+        : path.resolve(process.cwd(), trimmedPath);
+}
+async function assertReadableFile(filePath) {
+    let fileStat;
+    try {
+        fileStat = await stat(filePath);
+    }
+    catch {
+        throw new Error(`Image file does not exist: ${filePath}`);
+    }
+    if (!fileStat.isFile()) {
+        throw new Error(`Image path is not a file: ${filePath}`);
+    }
+}
+async function createWebpPostImage(filePath) {
+    try {
+        return await sharp(filePath)
+            .rotate()
+            .resize({
+            width: MAX_POST_IMAGE_WIDTH,
+            withoutEnlargement: true,
+        })
+            .webp({ quality: WEBP_QUALITY })
+            .toBuffer();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? ` ${error.message}` : "";
+        throw new Error(`Could not convert image to WebP.${detail}`);
+    }
+}
+async function putImage(uploadTarget, webp) {
+    const response = await fetch(uploadTarget.uploadUrl, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "image/webp",
+            ...(uploadTarget.headers ?? {}),
+        },
+        body: new Uint8Array(webp),
+    });
+    if (!response.ok) {
+        throw new Error(`Image upload failed with ${response.status}: ${await readResponseText(response)}`);
+    }
+}
+async function readResponseText(response) {
+    const text = await response.text().catch(() => "");
+    return text.trim() || response.statusText || "No response body";
+}
+function getMarkdownUrl(uploadTarget) {
+    if (uploadTarget.markdownUrl) {
+        return uploadTarget.markdownUrl;
+    }
+    if (uploadTarget.assetUrl) {
+        return uploadTarget.assetUrl;
+    }
+    if (uploadTarget.imageUrl) {
+        return uploadTarget.imageUrl;
+    }
+    if (uploadTarget.publicUrl) {
+        return uploadTarget.publicUrl;
+    }
+    if (uploadTarget.assetId !== undefined) {
+        return `/media/assets/${encodeURIComponent(String(uploadTarget.assetId))}`;
+    }
+    return undefined;
+}
+function normalizeAltText(providedAltText, originalFileName) {
+    const normalized = (providedAltText ?? "")
+        .trim()
+        .replace(/[\r\n]+/g, " ");
+    if (normalized) {
+        return normalized;
+    }
+    return stripExtension(originalFileName).replace(/[_-]+/g, " ").trim() || "image";
+}
+function sanitizeFileStem(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized || "image";
+}
+function stripExtension(fileName) {
+    return fileName.replace(/\.[^.]+$/, "");
+}
+function escapeMarkdownAltText(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/\[/g, "\\[")
+        .replace(/\]/g, "\\]")
+        .replace(/[\r\n]+/g, " ");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitae9999/openlog-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "Official OpenLog CLI and MCP server.",
   "type": "module",
@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "sharp": "^0.34.5",
     "zod": "^4.4.3"
   },
   "devDependencies": {