@kitae9999/openlog-cli 0.1.0 → 1.0.0

package/README.md

@@ -8,6 +8,18 @@ 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`
+- `push_working_brief`
+- `get_post_detail`
+
 MCP client configuration:
 
 ```json
@@ -21,4 +33,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

@@ -12,9 +12,14 @@ export class ApiError extends Error {
 export class OpenLogApiClient {
     apiBaseUrl;
     accessToken;
+    refreshToken;
+    onTokenRefresh;
+    refreshPromise;
     constructor(options = {}) {
         this.apiBaseUrl = (options.apiBaseUrl ?? getApiBaseUrl()).replace(/\/$/, "");
         this.accessToken = options.accessToken;
+        this.refreshToken = options.refreshToken;
+        this.onTokenRefresh = options.onTokenRefresh;
     }
     async get(path) {
         return this.request(path, { method: "GET" });
@@ -26,6 +31,13 @@ export class OpenLogApiClient {
             body: body ? JSON.stringify(body) : undefined,
         });
     }
+    async put(path, body) {
+        return this.request(path, {
+            method: "PUT",
+            headers: body ? { "content-type": "application/json" } : undefined,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
     async postNoContent(path, body) {
         await this.request(path, {
             method: "POST",
@@ -33,7 +45,14 @@ export class OpenLogApiClient {
             body: body ? JSON.stringify(body) : undefined,
         });
     }
-    async request(path, init) {
+    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, allowRefresh = true) {
         const url = `${this.apiBaseUrl}${path}`;
         const response = await fetch(url, {
             ...init,
@@ -44,6 +63,10 @@ export class OpenLogApiClient {
                     : {}),
             },
         });
+        if (response.status === 401 && allowRefresh && this.refreshToken) {
+            await this.refreshAccessToken();
+            return this.request(path, init, false);
+        }
         if (!response.ok) {
             throw new ApiError(response.status, url, await readErrorMessage(response));
         }
@@ -52,6 +75,37 @@ export class OpenLogApiClient {
         }
         return (await response.json());
     }
+    async refreshAccessToken() {
+        if (!this.refreshPromise) {
+            this.refreshPromise = this.performTokenRefresh().finally(() => {
+                this.refreshPromise = undefined;
+            });
+        }
+        await this.refreshPromise;
+    }
+    async performTokenRefresh() {
+        const response = await fetch(`${this.apiBaseUrl}/auth/device/refresh`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ refreshToken: this.refreshToken }),
+        });
+        if (!response.ok) {
+            throw new ApiError(response.status, `${this.apiBaseUrl}/auth/device/refresh`, await readErrorMessage(response));
+        }
+        const tokens = (await response.json());
+        if (!isRefreshedTokens(tokens)) {
+            throw new Error("OpenLog refresh response is incomplete.");
+        }
+        this.accessToken = tokens.accessToken;
+        this.refreshToken = tokens.refreshToken;
+        await this.onTokenRefresh?.(tokens);
+    }
+}
+function isRefreshedTokens(value) {
+    return Boolean(value.accessToken &&
+        value.refreshToken &&
+        Number.isFinite(value.expiresIn) &&
+        Number.isFinite(value.refreshExpiresIn));
 }
 async function readErrorMessage(response) {
     try {

package/dist/auth-store.js

@@ -10,8 +10,11 @@ export async function readAuthFile() {
         }
         return {
             accessToken: parsed.accessToken,
+            refreshToken: parsed.refreshToken,
             apiBaseUrl: parsed.apiBaseUrl,
             createdAt: parsed.createdAt,
+            accessTokenExpiresAt: parsed.accessTokenExpiresAt,
+            refreshTokenExpiresAt: parsed.refreshTokenExpiresAt,
         };
     }
     catch (error) {
@@ -24,20 +27,40 @@ export async function readAuthFile() {
         throw error;
     }
 }
-export async function writeAuthFile(accessToken) {
+export async function writeAuthFile(tokens) {
     const authFile = {
-        accessToken,
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
         apiBaseUrl: getApiBaseUrl(),
         createdAt: new Date().toISOString(),
+        accessTokenExpiresAt: expiresAt(tokens.expiresIn),
+        refreshTokenExpiresAt: expiresAt(tokens.refreshExpiresIn),
     };
+    await persistAuthFile(authFile);
+    return authFile;
+}
+export async function updateAuthFileTokens(authFile, tokens) {
+    const updatedAuthFile = {
+        ...authFile,
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        accessTokenExpiresAt: expiresAt(tokens.expiresIn),
+        refreshTokenExpiresAt: expiresAt(tokens.refreshExpiresIn),
+    };
+    await persistAuthFile(updatedAuthFile);
+    return updatedAuthFile;
+}
+async function persistAuthFile(authFile) {
     const authFilePath = getAuthFilePath();
     await mkdir(path.dirname(authFilePath), { recursive: true, mode: 0o700 });
     await writeFile(authFilePath, `${JSON.stringify(authFile, null, 2)}\n`, {
         mode: 0o600,
     });
     await chmod(authFilePath, 0o600);
-    return authFile;
 }
 export async function deleteAuthFile() {
     await rm(getAuthFilePath(), { force: true });
 }
+function expiresAt(expiresIn) {
+    return new Date(Date.now() + expiresIn * 1000).toISOString();
+}

package/dist/authenticated-client.js

@@ -0,0 +1,34 @@
+import { OpenLogApiClient } from "./api-client.js";
+import { readAuthFile, updateAuthFileTokens, } from "./auth-store.js";
+let cachedClient;
+export async function createAuthenticatedApiClient() {
+    const authFile = await readAuthFile();
+    if (!authFile) {
+        throw new Error("Run `openlog login` before using OpenLog.");
+    }
+    const fingerprint = authFingerprint(authFile);
+    if (cachedClient?.fingerprint === fingerprint) {
+        return cachedClient.client;
+    }
+    const client = new OpenLogApiClient({
+        accessToken: authFile.accessToken,
+        refreshToken: authFile.refreshToken,
+        apiBaseUrl: authFile.apiBaseUrl,
+        onTokenRefresh: async (tokens) => {
+            const updatedAuthFile = await updateAuthFileTokens(authFile, tokens);
+            cachedClient = {
+                fingerprint: authFingerprint(updatedAuthFile),
+                client,
+            };
+        },
+    });
+    cachedClient = { fingerprint, client };
+    return client;
+}
+function authFingerprint(authFile) {
+    return [
+        authFile.apiBaseUrl,
+        authFile.accessToken,
+        authFile.refreshToken ?? "",
+    ].join("\u0000");
+}

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

@@ -4,6 +4,7 @@ import { login } from "./login.js";
 import { runMcpServer } from "./mcp-server.js";
 import { installMcp, printMcpInstallHelp } from "./mcp-install.js";
 import { ApiError, OpenLogApiClient } from "./api-client.js";
+import { createAuthenticatedApiClient } from "./authenticated-client.js";
 const command = process.argv[2] ?? "help";
 const subcommand = process.argv[3];
 try {
@@ -11,8 +12,7 @@ try {
         await login();
     }
     else if (command === "logout") {
-        await deleteAuthFile();
-        console.log("Logged out.");
+        await logout();
     }
     else if (command === "whoami") {
         await whoami();
@@ -56,17 +56,28 @@ async function installMcpCommand() {
     });
 }
 async function whoami() {
-    const authFile = await readAuthFile();
-    if (!authFile) {
-        throw new Error("Not logged in. Run `openlog login` first.");
-    }
-    const apiClient = new OpenLogApiClient({
-        accessToken: authFile.accessToken,
-        apiBaseUrl: authFile.apiBaseUrl,
-    });
+    const apiClient = await createAuthenticatedApiClient();
     const me = await apiClient.get("/auth/me");
     console.log(JSON.stringify(me, null, 2));
 }
+async function logout() {
+    const authFile = await readAuthFile();
+    if (authFile?.refreshToken) {
+        try {
+            const apiClient = new OpenLogApiClient({
+                apiBaseUrl: authFile.apiBaseUrl,
+            });
+            await apiClient.postNoContent("/auth/device/revoke", {
+                refreshToken: authFile.refreshToken,
+            });
+        }
+        catch (error) {
+            console.error(`Warning: remote session revoke failed: ${formatCliError(error)}`);
+        }
+    }
+    await deleteAuthFile();
+    console.log("Logged out.");
+}
 function printMcpStartupHint() {
     if (!process.stderr.isTTY) {
         return;
@@ -90,7 +101,11 @@ Available tools:
   get_auth_status
   get_me
   list_my_notifications
+  list_my_posts
   list_my_liked_posts
+  upload_post_image
+  publish_post
+  push_working_brief
   get_post_detail
 `);
 }
@@ -109,6 +124,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/login.js

@@ -14,18 +14,18 @@ export async function login() {
         ? "The approval page was opened in your browser."
         : "Open the URL above in your browser.");
     console.log("Waiting for approval...");
-    const accessToken = await pollForAccessToken(apiClient, deviceLogin);
-    await writeAuthFile(accessToken);
+    const tokens = await pollForTokens(apiClient, deviceLogin);
+    await writeAuthFile(tokens);
     console.log("Login successful.");
 }
-async function pollForAccessToken(apiClient, deviceLogin) {
+async function pollForTokens(apiClient, deviceLogin) {
     const deadline = Date.now() + deviceLogin.expiresIn * 1000;
     let interval = deviceLogin.interval;
     while (Date.now() < deadline) {
         await sleep(interval * 1000);
         const response = await apiClient.post("/auth/device/token", { deviceCode: deviceLogin.deviceCode });
         if (response.status === "APPROVED") {
-            return response.accessToken;
+            return response;
         }
         interval = response.interval ?? interval;
     }

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

@@ -1,13 +1,20 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 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 { createAuthenticatedApiClient } from "./authenticated-client.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: "1.0.0",
     });
     server.registerTool("get_auth_status", {
         title: "Get OpenLog Auth Status",
@@ -24,7 +31,7 @@ export async function runMcpServer() {
                 });
             }
             apiBaseUrl = authFile.apiBaseUrl;
-            const me = await createAuthenticatedClient().then((client) => client.get("/auth/me"));
+            const me = await createAuthenticatedApiClient().then((client) => client.get("/auth/me"));
             return textResult({
                 authenticated: true,
                 apiBaseUrl: authFile.apiBaseUrl,
@@ -65,6 +72,107 @@ 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("push_working_brief", {
+        title: "Push OpenLog Working Brief",
+        description: "Overwrite the workspace Now Working brief with a short status update: what was done, what is still open, and optional task/branch context. Latest write wins.",
+        annotations: {
+            ...WRITE_TOOL_ANNOTATIONS,
+            idempotentHint: true,
+        },
+        inputSchema: {
+            workspaceId: z.number().int().positive(),
+            title: z.string().min(1).max(255),
+            prose: z.string().min(1),
+            taskId: z.number().int().positive().optional(),
+            branch: z.string().max(255).optional(),
+        },
+    }, async ({ workspaceId, title, prose, taskId, branch }) => withAuthenticatedClient((client) => client.put(`/workspaces/${workspaceId}/working-brief`, {
+        title,
+        prose,
+        taskId: taskId ?? null,
+        branch: branch ?? null,
+    })));
     server.registerTool("get_post_detail", {
         title: "Get OpenLog Post Detail",
         description: "Return a public OpenLog post detail by author username and post slug.",
@@ -75,19 +183,58 @@ export async function runMcpServer() {
     }, async ({ username, slug }) => withAuthenticatedClient((client) => client.get(`/users/${encodeURIComponent(username)}/posts/${encodeURIComponent(slug)}`)));
     await server.connect(new StdioServerTransport());
 }
-async function createAuthenticatedClient() {
-    const authFile = await readAuthFile();
-    if (!authFile) {
-        throw new Error("Run `openlog login` before using OpenLog MCP tools.");
+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.");
     }
-    return new OpenLogApiClient({
-        accessToken: authFile.accessToken,
-        apiBaseUrl: authFile.apiBaseUrl,
-    });
+    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 withAuthenticatedClient(callback) {
     try {
-        const client = await createAuthenticatedClient();
+        const client = await createAuthenticatedApiClient();
         const result = await callback(client);
         return textResult(result);
     }

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": "1.0.0",
   "private": false,
   "description": "Official OpenLog CLI and MCP server.",
   "type": "module",
@@ -16,7 +16,8 @@
     "build": "tsc && chmod 755 dist/index.js",
     "dev": "tsx src/index.ts",
     "prepack": "npm run build",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "test": "tsx --test test/**/*.test.ts"
   },
   "files": [
     "dist",
@@ -27,6 +28,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "sharp": "^0.34.5",
     "zod": "^4.4.3"
   },
   "devDependencies": {