@kitae9999/openlog-cli 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# OpenLog CLI
+
+Official CLI and MCP server for OpenLog.
+
+```bash
+npx -y @kitae9999/openlog-cli login
+npx -y @kitae9999/openlog-cli whoami
+npx -y @kitae9999/openlog-cli mcp
+```
+
+MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "openlog": {
+      "command": "npx",
+      "args": ["-y", "@kitae9999/openlog-cli", "mcp"]
+    }
+  }
+}
+```
+
+Set `OPENLOG_API_BASE_URL` to point at a non-production API.

package/dist/api-client.js

@@ -0,0 +1,64 @@
+import { getApiBaseUrl } from "./config.js";
+export class ApiError extends Error {
+    status;
+    url;
+    constructor(status, url, message) {
+        super(message);
+        this.status = status;
+        this.url = url;
+        this.name = "ApiError";
+    }
+}
+export class OpenLogApiClient {
+    apiBaseUrl;
+    accessToken;
+    constructor(options = {}) {
+        this.apiBaseUrl = (options.apiBaseUrl ?? getApiBaseUrl()).replace(/\/$/, "");
+        this.accessToken = options.accessToken;
+    }
+    async get(path) {
+        return this.request(path, { method: "GET" });
+    }
+    async post(path, body) {
+        return this.request(path, {
+            method: "POST",
+            headers: body ? { "content-type": "application/json" } : undefined,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    async postNoContent(path, body) {
+        await this.request(path, {
+            method: "POST",
+            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, {
+            ...init,
+            headers: {
+                ...(init.headers ?? {}),
+                ...(this.accessToken
+                    ? { cookie: `openlog_access_token=${this.accessToken}` }
+                    : {}),
+            },
+        });
+        if (!response.ok) {
+            throw new ApiError(response.status, url, await readErrorMessage(response));
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return (await response.json());
+    }
+}
+async function readErrorMessage(response) {
+    try {
+        const body = (await response.json());
+        return body.message ?? `OpenLog API request failed with ${response.status}`;
+    }
+    catch {
+        return `OpenLog API request failed with ${response.status}`;
+    }
+}

package/dist/auth-store.js

@@ -0,0 +1,43 @@
+import { mkdir, readFile, rm, writeFile, chmod } from "node:fs/promises";
+import path from "node:path";
+import { getApiBaseUrl, getAuthFilePath } from "./config.js";
+export async function readAuthFile() {
+    try {
+        const content = await readFile(getAuthFilePath(), "utf8");
+        const parsed = JSON.parse(content);
+        if (!parsed.accessToken || !parsed.apiBaseUrl || !parsed.createdAt) {
+            return null;
+        }
+        return {
+            accessToken: parsed.accessToken,
+            apiBaseUrl: parsed.apiBaseUrl,
+            createdAt: parsed.createdAt,
+        };
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeAuthFile(accessToken) {
+    const authFile = {
+        accessToken,
+        apiBaseUrl: getApiBaseUrl(),
+        createdAt: new Date().toISOString(),
+    };
+    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 });
+}

package/dist/browser.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+export function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config.js

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

package/dist/index.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { deleteAuthFile, readAuthFile } from "./auth-store.js";
+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";
+const command = process.argv[2] ?? "help";
+const subcommand = process.argv[3];
+try {
+    if (command === "login") {
+        await login();
+    }
+    else if (command === "logout") {
+        await deleteAuthFile();
+        console.log("Logged out.");
+    }
+    else if (command === "whoami") {
+        await whoami();
+    }
+    else if (command === "mcp") {
+        if (subcommand === "install") {
+            await installMcpCommand();
+        }
+        else if (subcommand === undefined ||
+            subcommand === "serve" ||
+            subcommand === "start") {
+            printMcpStartupHint();
+            await runMcpServer();
+        }
+        else {
+            printMcpInstallHelp();
+            process.exit(1);
+        }
+    }
+    else {
+        printHelp();
+        process.exit(command === "help" || command === "--help" || command === "-h" ? 0 : 1);
+    }
+}
+catch (error) {
+    console.error(formatCliError(error));
+    process.exit(1);
+}
+async function installMcpCommand() {
+    const client = process.argv[4];
+    const printOnly = process.argv.includes("--print");
+    if (client !== "codex" &&
+        client !== "claude-code" &&
+        client !== "claude") {
+        printMcpInstallHelp();
+        process.exit(1);
+    }
+    await installMcp({
+        client,
+        printOnly,
+    });
+}
+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 me = await apiClient.get("/auth/me");
+    console.log(JSON.stringify(me, null, 2));
+}
+function printMcpStartupHint() {
+    if (!process.stderr.isTTY) {
+        return;
+    }
+    console.error(`OpenLog MCP server is running over stdio.
+
+This terminal is now reserved for MCP protocol traffic.
+Press Ctrl+C to stop it.
+
+To use it from an MCP client, add:
+{
+  "mcpServers": {
+    "openlog": {
+      "command": "openlog",
+      "args": ["mcp"]
+    }
+  }
+}
+
+Available tools:
+  get_auth_status
+  get_me
+  list_my_notifications
+  list_my_liked_posts
+  get_post_detail
+`);
+}
+function printHelp() {
+    console.log(`OpenLog CLI
+
+Usage:
+  openlog login    Sign in to OpenLog from the CLI
+  openlog logout   Remove local OpenLog credentials
+  openlog whoami   Print the current OpenLog user
+  openlog mcp      Start the OpenLog MCP stdio server
+  openlog mcp install codex
+                  Register OpenLog MCP with Codex
+  openlog mcp install claude-code
+                  Register OpenLog MCP with Claude Code
+
+Environment:
+  OPENLOG_API_BASE_URL  Override the OpenLog API base URL
+  OPENLOG_AUTH_FILE     Override the local auth file path
+`);
+}
+function formatCliError(error) {
+    if (error instanceof ApiError && error.status === 404) {
+        const hint = error.url.includes("localhost:8080/auth/")
+            ? "\n\nLocal hint: if your backend uses SERVER_SERVLET_CONTEXT_PATH=/api, run with OPENLOG_API_BASE_URL=http://localhost:8080/api."
+            : "";
+        return `${error.message}\nRequested: ${error.url}${hint}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/login.js

@@ -0,0 +1,38 @@
+import { OpenLogApiClient } from "./api-client.js";
+import { openBrowser } from "./browser.js";
+import { writeAuthFile } from "./auth-store.js";
+export async function login() {
+    const apiClient = new OpenLogApiClient();
+    const deviceLogin = await apiClient.post("/auth/device/start");
+    const opened = openBrowser(deviceLogin.verificationUriComplete);
+    console.log("OpenLog CLI login");
+    console.log("");
+    console.log(`Code: ${deviceLogin.userCode}`);
+    console.log(`URL:  ${deviceLogin.verificationUriComplete}`);
+    console.log("");
+    console.log(opened
+        ? "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);
+    console.log("Login successful.");
+}
+async function pollForAccessToken(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;
+        }
+        interval = response.interval ?? interval;
+    }
+    throw new Error("CLI login expired before approval completed.");
+}
+function sleep(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}

package/dist/mcp-install.js

@@ -0,0 +1,199 @@
+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";
+export async function installMcp(options) {
+    const serverConfig = buildServerConfig();
+    if (options.printOnly) {
+        printConfig(options.client, serverConfig);
+        return;
+    }
+    if (options.client === "codex") {
+        await installCodex(serverConfig);
+        return;
+    }
+    await installClaudeCode(serverConfig);
+}
+export function printMcpInstallHelp() {
+    console.log(`OpenLog MCP install
+
+Usage:
+  openlog mcp install codex
+  openlog mcp install claude-code
+  openlog mcp install codex --print
+  openlog mcp install claude-code --print
+
+Aliases:
+  claude      Same as claude-code
+
+Notes:
+  If OPENLOG_API_BASE_URL is set, it is added to the client config.
+`);
+}
+function buildServerConfig() {
+    const apiBaseUrl = getApiBaseUrl();
+    const env = {};
+    if (apiBaseUrl !== DEFAULT_API_BASE_URL) {
+        env.OPENLOG_API_BASE_URL = apiBaseUrl;
+    }
+    return {
+        command: "openlog",
+        args: ["mcp"],
+        env,
+    };
+}
+async function installCodex(serverConfig) {
+    const args = ["mcp", "add", "openlog"];
+    for (const [name, value] of Object.entries(serverConfig.env)) {
+        args.push("--env", `${name}=${value}`);
+    }
+    args.push("--", serverConfig.command, ...serverConfig.args);
+    let registeredWithCodexCli = false;
+    try {
+        registeredWithCodexCli =
+            (await runCommand("codex", args, { stdio: "pipe" })) === "executed";
+    }
+    catch (error) {
+        warnCodexFallback(error);
+    }
+    if (registeredWithCodexCli) {
+        console.log("OpenLog MCP server registered with Codex.");
+        console.log("Run `/mcp` inside Codex to confirm it is connected.");
+        return;
+    }
+    await writeCodexConfig(serverConfig);
+    console.log("OpenLog MCP server added to ~/.codex/config.toml.");
+    console.log("Restart Codex or reload MCP servers, then run `/mcp` to confirm.");
+}
+async function installClaudeCode(serverConfig) {
+    const args = ["mcp", "add", "--transport", "stdio", "--scope", "user"];
+    for (const [name, value] of Object.entries(serverConfig.env)) {
+        args.push("--env", `${name}=${value}`);
+    }
+    args.push("openlog", "--", serverConfig.command, ...serverConfig.args);
+    const result = await runCommand("claude", args);
+    if (result !== "executed") {
+        throw new Error("Claude Code CLI was not found. Install Claude Code first, then run `openlog mcp install claude-code` again.");
+    }
+    console.log("OpenLog MCP server registered with Claude Code.");
+    console.log("Run `/mcp` inside Claude Code to confirm it is connected.");
+}
+async function writeCodexConfig(serverConfig) {
+    const configPath = path.join(os.homedir(), ".codex", "config.toml");
+    await mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+    const currentConfig = await readTextIfExists(configPath);
+    const nextConfig = upsertCodexServerBlock(currentConfig, serverConfig);
+    await writeFile(configPath, nextConfig, { mode: 0o600 });
+}
+function upsertCodexServerBlock(currentConfig, serverConfig) {
+    const block = buildCodexServerBlock(serverConfig);
+    const blockPattern = /(?:^|\n)\[mcp_servers\.openlog]\n[\s\S]*?(?:\n\[mcp_servers\.openlog\.env]\n[\s\S]*?)?(?=\n\[(?!mcp_servers\.openlog(?:\.env)?])[^\]]+]|\s*$)/;
+    if (blockPattern.test(currentConfig)) {
+        return currentConfig.replace(blockPattern, `\n${block}`).trimStart() + "\n";
+    }
+    const separator = currentConfig.trim().length === 0 ? "" : "\n\n";
+    return `${currentConfig.trimEnd()}${separator}${block}\n`;
+}
+function buildCodexServerBlock(serverConfig) {
+    const lines = [
+        "[mcp_servers.openlog]",
+        `command = ${tomlString(serverConfig.command)}`,
+        `args = [${serverConfig.args.map(tomlString).join(", ")}]`,
+    ];
+    if (Object.keys(serverConfig.env).length > 0) {
+        lines.push("");
+        lines.push("[mcp_servers.openlog.env]");
+        for (const [name, value] of Object.entries(serverConfig.env)) {
+            lines.push(`${name} = ${tomlString(value)}`);
+        }
+    }
+    return lines.join("\n");
+}
+function printConfig(client, serverConfig) {
+    if (client === "codex") {
+        console.log(buildCodexServerBlock(serverConfig));
+        return;
+    }
+    console.log(JSON.stringify({
+        type: "stdio",
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env,
+    }, null, 2));
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+class CommandFailedError extends Error {
+    exitCode;
+    stderr;
+    constructor(command, exitCode, stderr) {
+        super(`${command} exited with code ${exitCode ?? "unknown"}.`);
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+    }
+}
+async function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const stdioMode = options.stdio ?? "inherit";
+        const stdio = stdioMode === "pipe" ? ["ignore", "ignore", "pipe"] : "inherit";
+        let stderr = "";
+        const child = spawn(command, args, {
+            stdio,
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                resolve("missing");
+                return;
+            }
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve("executed");
+                return;
+            }
+            reject(new CommandFailedError(command, code, stderr));
+        });
+    });
+}
+function warnCodexFallback(error) {
+    const reason = summarizeCommandError(error);
+    const suffix = reason.length > 0 ? ` (${reason})` : "";
+    console.warn(`Codex CLI registration failed${suffix}. Falling back to ~/.codex/config.toml.`);
+}
+function summarizeCommandError(error) {
+    if (error instanceof CommandFailedError) {
+        const firstStderrLine = error.stderr
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0);
+        return truncateReason(firstStderrLine ?? error.message);
+    }
+    if (error instanceof Error) {
+        return truncateReason(error.message);
+    }
+    return truncateReason(String(error));
+}
+function truncateReason(reason) {
+    return reason.length > 180 ? `${reason.slice(0, 177)}...` : reason;
+}

package/dist/mcp-server.js

@@ -0,0 +1,115 @@
+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";
+export async function runMcpServer() {
+    const server = new McpServer({
+        name: "openlog",
+        version: "0.1.0",
+    });
+    server.registerTool("get_auth_status", {
+        title: "Get OpenLog Auth Status",
+        description: "Check whether the local OpenLog CLI is authenticated.",
+        inputSchema: {},
+    }, async () => {
+        let apiBaseUrl = getApiBaseUrl();
+        try {
+            const authFile = await readAuthFile();
+            if (!authFile) {
+                return textResult({
+                    authenticated: false,
+                    apiBaseUrl,
+                });
+            }
+            apiBaseUrl = authFile.apiBaseUrl;
+            const me = await createAuthenticatedClient().then((client) => client.get("/auth/me"));
+            return textResult({
+                authenticated: true,
+                apiBaseUrl: authFile.apiBaseUrl,
+                user: me,
+            });
+        }
+        catch (error) {
+            return textResult({
+                authenticated: false,
+                apiBaseUrl,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    server.registerTool("get_me", {
+        title: "Get OpenLog Me",
+        description: "Return the currently authenticated OpenLog user.",
+        inputSchema: {},
+    }, async () => withAuthenticatedClient((client) => client.get("/auth/me")));
+    server.registerTool("list_my_notifications", {
+        title: "List My OpenLog Notifications",
+        description: "Return notifications for the authenticated OpenLog user.",
+        inputSchema: {
+            size: z.number().int().min(1).max(20).default(20),
+        },
+    }, async ({ size }) => withAuthenticatedClient((client) => client.get(`/notifications?${new URLSearchParams({ size: String(size) })}`)));
+    server.registerTool("list_my_liked_posts", {
+        title: "List My Liked OpenLog Posts",
+        description: "Return posts liked by the authenticated OpenLog user.",
+        inputSchema: {
+            cursor: z.string().optional(),
+            size: z.number().int().min(1).max(20).default(10),
+        },
+    }, async ({ cursor, size }) => {
+        const params = new URLSearchParams({ size: String(size) });
+        if (cursor) {
+            params.set("cursor", cursor);
+        }
+        return withAuthenticatedClient((client) => client.get(`/users/me/liked-posts?${params}`));
+    });
+    server.registerTool("get_post_detail", {
+        title: "Get OpenLog Post Detail",
+        description: "Return a public OpenLog post detail by author username and post slug.",
+        inputSchema: {
+            username: z.string().min(1),
+            slug: z.string().min(1),
+        },
+    }, 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.");
+    }
+    return new OpenLogApiClient({
+        accessToken: authFile.accessToken,
+        apiBaseUrl: authFile.apiBaseUrl,
+    });
+}
+async function withAuthenticatedClient(callback) {
+    try {
+        const client = await createAuthenticatedClient();
+        const result = await callback(client);
+        return textResult(result);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : String(error),
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+function textResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof value === "string" ? value : JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@kitae9999/openlog-cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Official OpenLog CLI and MCP server.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kitae9999/OpenLog.git",
+    "directory": "packages/openlog-cli"
+  },
+  "bin": {
+    "openlog": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepack": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3"
+  }
+}