@kiipu/cli 0.0.1

package/README.md

@@ -0,0 +1,38 @@
+# Kiipu CLI
+
+`@kiipu/cli` is the publishable npm package for Kiipu local tooling.
+
+It ships:
+
+- the `kiipu` CLI
+- `kiipu skills` guidance for the Claude Code plugin package
+- `kiipu doctor`
+- direct post create/delete/restore/purge commands
+
+The Kiipu CLI is the stable local control-plane entrypoint for:
+
+- authentication
+- direct publishing actions
+- install and doctor checks
+
+Claude Code plugin assets now publish separately from `@kiipu/claude-plugin`.
+
+## Standalone Repo Sync
+
+Export a clean standalone CLI repository snapshot from the monorepo root:
+
+```bash
+pnpm export:cli:repo
+```
+
+Push that exported snapshot to a dedicated GitHub repository:
+
+```bash
+pnpm sync:cli:repo -- git@github.com:kiipu/cli.git
+```
+
+If your SSH remote is the default `kiipu/cli` repository, you can use:
+
+```bash
+pnpm sync:cli:ssh
+```

package/dist/commands/auth.js

@@ -0,0 +1,70 @@
+import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
+import { saveKiipuConfig } from '../config/config.js';
+export async function runAuthCommand(config, input) {
+    if (input.action === 'logout') {
+        delete config.apiKey;
+        delete config.keyPrefix;
+        delete config.authUserId;
+        delete config.authUsername;
+        await saveKiipuConfig(config);
+        return {
+            ok: true,
+            message: 'Kiipu API key authentication was cleared from the local config.',
+        };
+    }
+    if (input.action === 'status') {
+        if (!config.apiKey) {
+            return {
+                ok: true,
+                message: 'Kiipu CLI is not authenticated yet. Run `kiipu auth login --api-key <cpk_...>` first.',
+            };
+        }
+        const client = new KiipuUserApiClient({
+            apiBaseUrl: config.apiBaseUrl,
+            apiKey: config.apiKey,
+        });
+        const response = await client.getApiKeyMe();
+        if (!response.ok) {
+            return {
+                ok: false,
+                message: response.error.message,
+            };
+        }
+        config.keyPrefix = response.data.keyPrefix ?? config.keyPrefix;
+        config.authUserId = response.data.userId;
+        config.authUsername = response.data.username;
+        await saveKiipuConfig(config);
+        return {
+            ok: true,
+            message: `Authenticated as ${response.data.username} (${response.data.displayName}) with key ${response.data.keyPrefix ?? 'unknown'}.`,
+            data: response.data,
+        };
+    }
+    if (!input.apiKey) {
+        return {
+            ok: false,
+            message: 'Usage: kiipu auth login --api-key <cpk_...>',
+        };
+    }
+    const client = new KiipuUserApiClient({
+        apiBaseUrl: config.apiBaseUrl,
+        apiKey: input.apiKey,
+    });
+    const response = await client.getApiKeyMe();
+    if (!response.ok) {
+        return {
+            ok: false,
+            message: response.error.message,
+        };
+    }
+    config.apiKey = input.apiKey;
+    config.keyPrefix = response.data.keyPrefix ?? undefined;
+    config.authUserId = response.data.userId;
+    config.authUsername = response.data.username;
+    await saveKiipuConfig(config);
+    return {
+        ok: true,
+        message: `Authenticated as ${response.data.username} (${response.data.displayName}). Key ${response.data.keyPrefix ?? 'unknown'} is now stored locally.`,
+        data: response.data,
+    };
+}

package/dist/commands/doctor.js

@@ -0,0 +1,47 @@
+import { KiipuUserApiClient } from '../lib/kiipu-user-client.js';
+import { access } from 'node:fs/promises';
+import { getDefaultConfigPath } from '../config/config.js';
+import { logCliEvent } from '../logger/cli-logger.js';
+export async function runDoctorCommand(config) {
+    logCliEvent('doctor_start');
+    const configPath = getDefaultConfigPath();
+    if (!config) {
+        return {
+            ok: false,
+            message: `Missing config at ${configPath}. Run \`kiipu auth login --api-key <cpk_...>\` first.`,
+        };
+    }
+    const checks = [];
+    checks.push(config.apiKey ? `OK API key: ${config.keyPrefix ?? 'configured'}` : 'Missing API key. Run `kiipu auth login --api-key <cpk_...>`.');
+    checks.push(config.apiKey || process.env.KIIPU_API_KEY ? 'OK post API auth: configured' : 'Missing API key for post requests.');
+    let apiStatus = 'API unreachable';
+    try {
+        const response = await fetch(`${config.apiBaseUrl}/health`);
+        apiStatus = response.ok ? 'API reachable' : `API returned ${response.status}`;
+    }
+    catch {
+        apiStatus = `API unreachable at ${config.apiBaseUrl}`;
+    }
+    checks.push(apiStatus);
+    if (config.apiKey) {
+        const authStatus = await new KiipuUserApiClient({
+            apiBaseUrl: config.apiBaseUrl,
+            apiKey: config.apiKey,
+        }).getApiKeyMe();
+        checks.push(authStatus.ok ? `OK API key auth: ${authStatus.data.username}` : `API key auth failed: ${authStatus.error.message}`);
+    }
+    try {
+        await access(configPath);
+        checks.push(`OK config: ${configPath}`);
+    }
+    catch {
+        checks.push(`Missing config file: ${configPath}`);
+    }
+    logCliEvent('doctor_complete', {
+        ok: checks.every((line) => line.startsWith('OK') || line.includes('reachable')),
+    });
+    return {
+        ok: true,
+        message: checks.join('\n'),
+    };
+}

package/dist/commands/help.js

@@ -0,0 +1,131 @@
+function block(lines) {
+    return lines.join('\n');
+}
+export function getHelpResult(command) {
+    if (command === 'post') {
+        return {
+            ok: true,
+            message: block([
+                'Kiipu CLI',
+                '',
+                'Usage:',
+                '  kiipu post create --content "<text>"',
+                '  kiipu post create "<text>"',
+                '  kiipu post delete --id <postId>',
+                '  kiipu post restore --id <postId>',
+                '  kiipu post purge --id <postId>',
+                '',
+                'Description:',
+                '  Run direct Kiipu post actions from the local CLI.',
+                '',
+                'Actions:',
+                '  create      Create a new post',
+                '  delete      Soft-delete an existing post by explicit id',
+                '  restore     Restore a deleted post by explicit id',
+                '  purge       Permanently delete a post by explicit id',
+                '',
+                'Options:',
+                '  --content "<text>"         Post content for create',
+                '  --id <postId>              Required for delete, restore, and purge',
+                '',
+                'Examples:',
+                '  kiipu post create "Hello Kiipu"',
+                '  kiipu post create --content "Hello Kiipu"',
+                '  kiipu post delete --id 123',
+                '  kiipu post restore --id 123',
+            ]),
+        };
+    }
+    if (command === 'skills') {
+        return {
+            ok: true,
+            message: block([
+                'Kiipu CLI',
+                '',
+                'Skills:',
+                '  Claude Code plugin support is published from the separate `@kiipu/claude-plugin` package.',
+                '',
+                'Examples:',
+                '  kiipu skills',
+                '  npm view @kiipu/claude-plugin version',
+                '  claude --plugin-dir ./apps/claude-plugin',
+            ]),
+        };
+    }
+    if (command === 'auth') {
+        return {
+            ok: true,
+            message: block([
+                'Kiipu CLI',
+                '',
+                'Usage:',
+                '  kiipu auth login --api-key <cpk_...>',
+                '  kiipu auth status',
+                '  kiipu auth logout',
+                '',
+                'Description:',
+                '  Manage local Kiipu API key authentication.',
+                '',
+                'Options:',
+                '  --api-key <cpk_...>   API key created on /connect. Required for login.',
+                '',
+                'Examples:',
+                '  kiipu auth login --api-key cpk_abc123...',
+                '  kiipu auth status',
+                '  kiipu auth logout',
+            ]),
+        };
+    }
+    if (command === 'doctor') {
+        return {
+            ok: true,
+            message: block([
+                'Kiipu CLI',
+                '',
+                'Usage:',
+                '  kiipu doctor',
+                '',
+                'Description:',
+                '  Inspect local setup and API reachability for the local CLI.',
+                '',
+                'Checks:',
+                '  - local Kiipu config exists',
+                '  - API health and API key auth are reachable',
+            ]),
+        };
+    }
+    return {
+        ok: true,
+        message: block([
+            'Kiipu CLI',
+            '',
+            'Usage:',
+            '  kiipu <command> [options]',
+            '',
+            'Core commands:',
+            '  post               Create, delete, restore, or purge posts with direct CLI arguments',
+            '  auth               Manage local API key authentication',
+            '  doctor             Check local setup, API access, and wrapper readiness',
+            '  skills             Show where the Claude Code plugin package lives',
+            '',
+            'Core examples:',
+            '  kiipu post create "Hello Kiipu"',
+            '  kiipu post delete --id 123',
+            '  kiipu auth login --api-key <cpk_...>',
+            '  kiipu doctor',
+            '  claude --plugin-dir ./apps/claude-plugin',
+            '',
+            'Claude Code plugin:',
+            '  kiipu skills',
+            '',
+            'Global options:',
+            '  --json             Print structured JSON instead of plain text',
+            '  -h, --help        Show help for the root CLI or a subcommand',
+            '',
+            'Help:',
+            '  kiipu --help',
+            '  kiipu -h',
+            '  kiipu <command> --help',
+        ]),
+    };
+}

package/dist/commands/post.js

@@ -0,0 +1,27 @@
+import { executePostAction } from '../lib/post-actions.js';
+export async function runPostCommand(config, input) {
+    if (input.action === 'create') {
+        const content = input.content?.trim();
+        if (!content) {
+            return {
+                ok: false,
+                message: 'Usage: kiipu post create --content "<text>"\n   or: kiipu post create "<text>"',
+            };
+        }
+        return executePostAction(config, {
+            action: 'create',
+            content,
+        });
+    }
+    const postId = input.postId?.trim();
+    if (!postId) {
+        return {
+            ok: false,
+            message: `Usage: kiipu post ${input.action} --id <postId>`,
+        };
+    }
+    return executePostAction(config, {
+        action: input.action,
+        postId,
+    });
+}

package/dist/commands/skills.js

@@ -0,0 +1,18 @@
+export async function runSkillsCommand() {
+    return {
+        ok: true,
+        message: [
+            'Kiipu skills',
+            'Claude Code plugin package: @kiipu/claude-plugin',
+            'Local plugin directory: ./apps/claude-plugin',
+            '',
+            'Next actions:',
+            '  claude --plugin-dir ./apps/claude-plugin',
+            '  npm view @kiipu/claude-plugin version',
+        ].join('\n'),
+        data: {
+            packageName: '@kiipu/claude-plugin',
+            pluginDir: './apps/claude-plugin',
+        },
+    };
+}

package/dist/config/config.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function getKiipuConfigHome() {
+    if (process.env.KIIPU_CONFIG_HOME) {
+        return process.env.KIIPU_CONFIG_HOME;
+    }
+    return path.join(os.homedir(), '.config', 'kiipu');
+}
+export function getDefaultConfigPath() {
+    return path.join(getKiipuConfigHome(), 'config.json');
+}
+export function createDefaultConfig() {
+    return {
+        apiBaseUrl: process.env.KIIPU_API_URL ?? 'http://localhost:4000',
+    };
+}
+export async function loadKiipuConfig(configPath = getDefaultConfigPath()) {
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    const content = await readFile(configPath, 'utf8');
+    const raw = JSON.parse(content);
+    const nextConfig = createDefaultConfig();
+    if (typeof raw.apiBaseUrl === 'string') {
+        nextConfig.apiBaseUrl = raw.apiBaseUrl;
+    }
+    if (typeof raw.apiKey === 'string') {
+        nextConfig.apiKey = raw.apiKey;
+    }
+    if (typeof raw.keyPrefix === 'string') {
+        nextConfig.keyPrefix = raw.keyPrefix;
+    }
+    if (typeof raw.authUserId === 'string') {
+        nextConfig.authUserId = raw.authUserId;
+    }
+    if (typeof raw.authUsername === 'string') {
+        nextConfig.authUsername = raw.authUsername;
+    }
+    return nextConfig;
+}
+export async function saveKiipuConfig(config, configPath = getDefaultConfigPath()) {
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+}

package/dist/config/load-env.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from 'node:fs';
+function parseEnvFile(content) {
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        if (!key || process.env[key] !== undefined) {
+            continue;
+        }
+        const value = line.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+        process.env[key] = value;
+    }
+}
+function loadLocalEnv() {
+    const filePath = `${process.cwd()}/.env`;
+    if (!existsSync(filePath)) {
+        return;
+    }
+    parseEnvFile(readFileSync(filePath, 'utf8'));
+}
+loadLocalEnv();

package/dist/index.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import './config/load-env.js';
+import { createDefaultConfig, loadKiipuConfig } from './config/config.js';
+import { runAuthCommand } from './commands/auth.js';
+import { runDoctorCommand } from './commands/doctor.js';
+import { getHelpResult } from './commands/help.js';
+import { runPostCommand } from './commands/post.js';
+import { runSkillsCommand } from './commands/skills.js';
+import { readFlag, hasFlag } from './utils/args.js';
+function printResult(result, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(result.message);
+    }
+    if (!result.ok) {
+        process.exitCode = 1;
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const normalizedArgs = args[0] === '--' ? args.slice(1) : args;
+    const asJson = hasFlag(normalizedArgs, '--json');
+    const wantsHelp = hasFlag(normalizedArgs, '--help') || hasFlag(normalizedArgs, '-h');
+    const positionalArgs = normalizedArgs.filter((arg, index, all) => {
+        if (arg === '--json' || arg === '--help' || arg === '-h')
+            return false;
+        const prev = all[index - 1];
+        return (prev !== '--scheduled-at' &&
+            prev !== '--package-root' &&
+            prev !== '--skills-dir' &&
+            prev !== '--text' &&
+            prev !== '--content' &&
+            prev !== '--id' &&
+            prev !== '--api-key' &&
+            prev !== '--config-path' &&
+            prev !== '--wrapper-path' &&
+            prev !== '--conversation-id' &&
+            prev !== '--device-name');
+    });
+    const [command, subcommand, subject] = positionalArgs;
+    if (wantsHelp || command === 'help') {
+        return printResult(getHelpResult(command === 'help' ? subcommand : command), asJson);
+    }
+    const config = (await loadKiipuConfig()) ?? createDefaultConfig();
+    let result;
+    if (command === 'skills') {
+        if (wantsHelp || !subcommand) {
+            result = getHelpResult('skills');
+            return printResult(result, asJson);
+        }
+        result = await runSkillsCommand();
+        return printResult(result, asJson);
+    }
+    if (command === 'doctor') {
+        result = await runDoctorCommand(await loadKiipuConfig());
+        return printResult(result, asJson);
+    }
+    if (command === 'post') {
+        const action = subcommand;
+        if (!action || !['create', 'delete', 'restore', 'purge'].includes(action)) {
+            result = getHelpResult('post');
+            return printResult(result, asJson);
+        }
+        result = await runPostCommand(config, {
+            action,
+            content: readFlag(normalizedArgs, '--content') ?? subject,
+            postId: readFlag(normalizedArgs, '--id'),
+        });
+        if (!result.ok) {
+            return printResult(action === 'create' && !(readFlag(normalizedArgs, '--content') ?? subject) ? getHelpResult('post') : result, asJson);
+        }
+        return printResult(result, asJson);
+    }
+    if (command === 'auth') {
+        const action = subcommand;
+        if (!action || !['login', 'status', 'logout'].includes(action)) {
+            result = getHelpResult('auth');
+            return printResult(result, asJson);
+        }
+        result = await runAuthCommand(config, {
+            action,
+            apiKey: readFlag(normalizedArgs, '--api-key'),
+        });
+        return printResult(result, asJson);
+    }
+    result = getHelpResult();
+    printResult(result, asJson);
+}
+void main();

package/dist/lib/kiipu-skill-client.js

@@ -0,0 +1,104 @@
+function buildError(requestId, message, code = 'request_failed') {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+            requestId,
+        },
+    };
+}
+function parseCreatePostRequest(input) {
+    const requestId = typeof input.requestId === 'string' ? input.requestId : crypto.randomUUID();
+    const rawText = typeof input.rawText === 'string' ? input.rawText.trim() : '';
+    if (!rawText) {
+        throw new Error('rawText is required.');
+    }
+    const visibility = input.visibility;
+    const tags = Array.isArray(input.tags) ? input.tags.filter((tag) => typeof tag === 'string') : [];
+    return {
+        requestId,
+        requestedAt: typeof input.requestedAt === 'string' ? input.requestedAt : undefined,
+        traceId: typeof input.traceId === 'string' ? input.traceId : undefined,
+        rawText,
+        sourceType: input.sourceType === 'manual' || input.sourceType === 'imported' || input.sourceType === 'skill_command'
+            ? input.sourceType
+            : 'skill_command',
+        finalText: typeof input.finalText === 'string' ? input.finalText : undefined,
+        visibility: visibility === 'unlisted' || visibility === 'private' || visibility === 'public' ? visibility : 'public',
+        sourceMessageId: typeof input.sourceMessageId === 'string' ? input.sourceMessageId : undefined,
+        title: typeof input.title === 'string' ? input.title : input.title === null ? null : undefined,
+        tags,
+    };
+}
+function parsePostMutationRequest(input) {
+    const requestId = typeof input.requestId === 'string' ? input.requestId : crypto.randomUUID();
+    const postId = typeof input.postId === 'string' ? input.postId.trim() : '';
+    if (!postId) {
+        throw new Error('postId is required.');
+    }
+    return {
+        requestId,
+        requestedAt: typeof input.requestedAt === 'string' ? input.requestedAt : undefined,
+        traceId: typeof input.traceId === 'string' ? input.traceId : undefined,
+        postId,
+    };
+}
+export class KiipuSkillApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async request(path, method, body) {
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+            return buildError(body.requestId, `Kiipu API is unreachable at ${this.config.apiBaseUrl}.`, 'api_unreachable');
+        }
+        const payload = (await response.json());
+        if (response.ok) {
+            return {
+                ok: true,
+                requestId: typeof payload.requestId === 'string' ? payload.requestId : body.requestId,
+                data: payload.data ?? {},
+            };
+        }
+        return buildError(body.requestId, typeof payload.message === 'string'
+            ? payload.message
+            : typeof payload.message === 'object' && typeof payload.message?.message === 'string'
+                ? payload.message.message
+                : typeof payload.error?.message === 'string'
+                    ? payload.error.message
+                    : 'CLI request failed.', typeof payload.message === 'object' && typeof payload.message?.code === 'string'
+            ? payload.message.code
+            : typeof payload.error?.code === 'string'
+                ? payload.error.code
+                : typeof payload.code === 'string'
+                    ? payload.code
+                    : 'request_failed');
+    }
+    createPost(input) {
+        return this.request('/skill/posts', 'POST', parseCreatePostRequest(input));
+    }
+    deletePost(input) {
+        const body = parsePostMutationRequest(input);
+        return this.request(`/skill/posts/${body.postId}/delete`, 'POST', body);
+    }
+    restorePost(input) {
+        const body = parsePostMutationRequest(input);
+        return this.request(`/skill/posts/${body.postId}/restore`, 'POST', body);
+    }
+    permanentDeletePost(input) {
+        const body = parsePostMutationRequest(input);
+        return this.request(`/skill/posts/${body.postId}/permanent-delete`, 'POST', body);
+    }
+}

package/dist/lib/kiipu-user-client.js

@@ -0,0 +1,50 @@
+function buildError(message, code = 'request_failed') {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+export class KiipuUserApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async request(path, init) {
+        let response;
+        try {
+            response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+                ...init,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    ...(init?.headers ?? {}),
+                },
+            });
+        }
+        catch {
+            return buildError(`Kiipu API is unreachable at ${this.config.apiBaseUrl}.`, 'api_unreachable');
+        }
+        const payload = (await response.json());
+        if (response.ok) {
+            return {
+                ok: true,
+                data: (payload.data ?? payload),
+            };
+        }
+        return buildError(typeof payload.message === 'string'
+            ? payload.message
+            : typeof payload.message?.message === 'string'
+                ? payload.message.message
+                : `Request failed with ${response.status}.`, typeof payload.code === 'string'
+            ? payload.code
+            : typeof payload.message === 'object' && typeof payload.message?.code === 'string'
+                ? payload.message.code
+                : 'request_failed');
+    }
+    getApiKeyMe() {
+        return this.request('/auth/api-key/me');
+    }
+}

package/dist/lib/post-actions.js

@@ -0,0 +1,113 @@
+import { KiipuSkillApiClient } from './kiipu-skill-client.js';
+function formatRequestFailed(message, code) {
+    return `Request failed: ${message} (${code}).`;
+}
+function getPostApiClient(config) {
+    const apiKey = config.apiKey ?? process.env.KIIPU_API_KEY ?? '';
+    if (!apiKey) {
+        return {
+            error: {
+                ok: false,
+                message: 'Kiipu API key is missing. Run `kiipu auth login --api-key <cpk_...>` first.',
+            },
+        };
+    }
+    return {
+        client: new KiipuSkillApiClient({
+            apiBaseUrl: config.apiBaseUrl,
+            apiKey,
+        }),
+    };
+}
+export async function executePostAction(config, input) {
+    const { client, error } = getPostApiClient(config);
+    if (!client) {
+        return error;
+    }
+    if (input.action === 'create') {
+        const response = await client.createPost({
+            requestId: crypto.randomUUID(),
+            requestedAt: new Date().toISOString(),
+            traceId: `${input.traceIdPrefix ?? 'post'}-${Date.now()}`,
+            rawText: input.content,
+            sourceType: 'skill_command',
+            sourceMessageId: input.sourceMessageId ?? `local-${Date.now()}`,
+            visibility: 'public',
+            tags: ['kiipu'],
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                message: formatRequestFailed(response.error.message, response.error.code),
+            };
+        }
+        return {
+            ok: true,
+            message: `Post published. Post id ${String(response.data.id)} is now visible in the feed.`,
+            data: response.data,
+            requestId: response.requestId,
+            postId: String(response.data.id),
+        };
+    }
+    if (input.action === 'delete') {
+        const response = await client.deletePost({
+            requestId: crypto.randomUUID(),
+            requestedAt: new Date().toISOString(),
+            traceId: `${input.traceIdPrefix ?? 'delete'}-${Date.now()}`,
+            postId: input.postId,
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                message: formatRequestFailed(response.error.message, response.error.code),
+            };
+        }
+        return {
+            ok: true,
+            message: 'Post deleted. The current post is no longer visible in the feed.',
+            data: response.data,
+            requestId: response.requestId,
+            postId: null,
+        };
+    }
+    if (input.action === 'restore') {
+        const response = await client.restorePost({
+            requestId: crypto.randomUUID(),
+            requestedAt: new Date().toISOString(),
+            traceId: `${input.traceIdPrefix ?? 'restore'}-${Date.now()}`,
+            postId: input.postId,
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                message: formatRequestFailed(response.error.message, response.error.code),
+            };
+        }
+        return {
+            ok: true,
+            message: `Post restored. Post id ${input.postId} is now back in the feed.`,
+            data: response.data,
+            requestId: response.requestId,
+            postId: input.postId,
+        };
+    }
+    const response = await client.permanentDeletePost({
+        requestId: crypto.randomUUID(),
+        requestedAt: new Date().toISOString(),
+        traceId: `${input.traceIdPrefix ?? 'purge'}-${Date.now()}`,
+        postId: input.postId,
+    });
+    if (!response.ok) {
+        return {
+            ok: false,
+            message: formatRequestFailed(response.error.message, response.error.code),
+        };
+    }
+    return {
+        ok: true,
+        message: `Post permanently deleted. Post id ${input.postId} has been removed from the database.`,
+        data: response.data,
+        requestId: response.requestId,
+        postId: null,
+    };
+}

package/dist/logger/cli-logger.js

@@ -0,0 +1,9 @@
+export function logCliEvent(event, details = {}) {
+    const payload = {
+        scope: 'kiipu-cli',
+        event,
+        timestamp: new Date().toISOString(),
+        ...details,
+    };
+    console.error(`[kiipu-cli] ${JSON.stringify(payload)}`);
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/args.js

@@ -0,0 +1,10 @@
+export function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+export function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1) {
+        return undefined;
+    }
+    return args[index + 1]?.trim();
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kiipu/cli",
+  "version": "0.0.1",
+  "description": "Kiipu CLI for local authentication, doctor checks, and direct post actions.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kiipu/kiipu.git"
+  },
+  "keywords": [
+    "kiipu",
+    "cli",
+    "skill"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "kiipu": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node --import tsx src/index.ts",
+    "build": "node scripts/clean-build.mjs && tsc -p tsconfig.json",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false eslint src test --ext .ts",
+    "test": "node --import tsx --test test/**/*.test.ts",
+    "release:patch": "npm version patch --no-git-tag-version",
+    "release:minor": "npm version minor --no-git-tag-version",
+    "release:major": "npm version major --no-git-tag-version",
+    "pack:local": "node scripts/pack-local.mjs",
+    "verify:package": "node scripts/verify-package.mjs",
+    "publish:dry-run": "npm publish --dry-run"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.8.1",
+    "@typescript-eslint/eslint-plugin": "^8.12.2",
+    "@typescript-eslint/parser": "^8.12.2",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
+  }
+}