@gitim-runtime/cli 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+export interface ApiResponse {
+    ok: boolean;
+    data?: any;
+    error?: string;
+}
+export declare class GitimClient {
+    private socketPath;
+    constructor(repoRoot: string);
+    request(method: string, params?: Record<string, any>): Promise<ApiResponse>;
+    status(): Promise<ApiResponse>;
+    send(channel: string, body: string, author?: string, replyTo?: number): Promise<ApiResponse>;
+    read(channel: string, limit?: number, since?: number): Promise<ApiResponse>;
+    listChannels(): Promise<ApiResponse>;
+    listUsers(): Promise<ApiResponse>;
+    getThread(channel: string, lineNumber: number): Promise<ApiResponse>;
+    registerUser(handler: string, displayName: string, role?: string, introduction?: string): Promise<ApiResponse>;
+    onboard(gitServer: string, auth: Record<string, string>, admin?: boolean, guest?: boolean): Promise<ApiResponse>;
+    joinChannel(channel: string, targets?: string[]): Promise<ApiResponse>;
+    leaveChannel(channel: string, targets?: string[]): Promise<ApiResponse>;
+    createChannel(name: string, displayName?: string, introduction?: string): Promise<ApiResponse>;
+    archiveChannel(channel: string): Promise<ApiResponse>;
+    listArchivedChannels(): Promise<ApiResponse>;
+    stop(): Promise<ApiResponse>;
+    poll(since?: string): Promise<ApiResponse>;
+    search(params: {
+        query?: string;
+        author?: string;
+        channel?: string;
+        channel_type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse>;
+    reindex(): Promise<ApiResponse>;
+}

package/dist/client.js

@@ -0,0 +1,99 @@
+import net from 'node:net';
+import path from 'node:path';
+import readline from 'node:readline';
+export class GitimClient {
+    socketPath;
+    constructor(repoRoot) {
+        this.socketPath = path.join(repoRoot, '.gitim', 'run', 'gitim.sock');
+    }
+    async request(method, params = {}) {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(this.socketPath);
+            const payload = JSON.stringify({ method, ...params }) + '\n';
+            socket.on('connect', () => {
+                socket.write(payload);
+            });
+            const rl = readline.createInterface({ input: socket });
+            rl.on('error', () => { }); // socket error is already handled below
+            rl.on('line', (line) => {
+                try {
+                    resolve(JSON.parse(line));
+                }
+                catch {
+                    reject(new Error(`Invalid response: ${line}`));
+                }
+                socket.end();
+            });
+            socket.on('error', (err) => {
+                reject(new Error(`Cannot connect to daemon: ${err.message}`));
+            });
+        });
+    }
+    async status() {
+        return this.request('status');
+    }
+    async send(channel, body, author, replyTo) {
+        return this.request('send', { channel, body, author: author ?? null, reply_to: replyTo ?? null });
+    }
+    async read(channel, limit, since) {
+        return this.request('read', { channel, limit: limit ?? null, since: since ?? null });
+    }
+    async listChannels() {
+        return this.request('channels');
+    }
+    async listUsers() {
+        return this.request('users');
+    }
+    async getThread(channel, lineNumber) {
+        return this.request('thread', { channel, line_number: lineNumber });
+    }
+    async registerUser(handler, displayName, role, introduction) {
+        return this.request('register_user', {
+            handler,
+            display_name: displayName,
+            role: role ?? 'member',
+            introduction: introduction ?? 'GitIM user',
+        });
+    }
+    async onboard(gitServer, auth, admin, guest) {
+        return this.request('onboard', { git_server: gitServer, auth, admin: admin ?? false, guest: guest ?? false });
+    }
+    async joinChannel(channel, targets) {
+        return this.request('join_channel', { channel, targets: targets ?? [] });
+    }
+    async leaveChannel(channel, targets) {
+        return this.request('leave_channel', { channel, targets: targets ?? [] });
+    }
+    async createChannel(name, displayName, introduction) {
+        return this.request('create_channel', {
+            name,
+            display_name: displayName,
+            introduction,
+        });
+    }
+    async archiveChannel(channel) {
+        return this.request('archive_channel', { channel });
+    }
+    async listArchivedChannels() {
+        return this.request('archived_channels');
+    }
+    async stop() {
+        return this.request('stop');
+    }
+    async poll(since) {
+        return this.request('poll', { since: since ?? null });
+    }
+    async search(params) {
+        return this.request('search', {
+            query: params.query ?? null,
+            author: params.author ?? null,
+            channel: params.channel ?? null,
+            channel_type: params.channel_type ?? null,
+            limit: params.limit ?? 50,
+            offset: params.offset ?? 0,
+        });
+    }
+    async reindex() {
+        return this.request('reindex');
+    }
+}

package/dist/commands/archive-channel.d.ts

@@ -0,0 +1 @@
+export declare function archiveChannelCommand(name: string): Promise<void>;

package/dist/commands/archive-channel.js

@@ -0,0 +1,19 @@
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+export async function archiveChannelCommand(name) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const res = await client.archiveChannel(name);
+    if (res.ok) {
+        console.log(`频道 #${name} 已归档`);
+    }
+    else {
+        console.error(`归档失败: ${res.error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/archived-channels.d.ts

@@ -0,0 +1 @@
+export declare function archivedChannelsCommand(): Promise<void>;

package/dist/commands/archived-channels.js

@@ -0,0 +1,26 @@
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+export async function archivedChannelsCommand() {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const res = await client.listArchivedChannels();
+    if (res.ok) {
+        const channels = res.data.channels;
+        if (channels.length === 0) {
+            console.log('暂无已归档频道');
+        }
+        else {
+            for (const ch of channels) {
+                console.log(`#${ch.name}`);
+            }
+        }
+    }
+    else {
+        console.error('Error:', res.error);
+    }
+}

package/dist/commands/channels.d.ts

@@ -0,0 +1 @@
+export declare function channelsCommand(): Promise<void>;

package/dist/commands/channels.js

@@ -0,0 +1,18 @@
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+export async function channelsCommand() {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const res = await client.listChannels();
+    if (res.ok) {
+        console.log(JSON.stringify(res.data, null, 2));
+    }
+    else {
+        console.error('Error:', res.error);
+    }
+}

package/dist/commands/create-channel.d.ts

@@ -0,0 +1,4 @@
+export declare function createChannelCommand(name: string, options: {
+    displayName?: string;
+    introduction?: string;
+}): Promise<void>;

package/dist/commands/create-channel.js

@@ -0,0 +1,19 @@
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+export async function createChannelCommand(name, options) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const res = await client.createChannel(name, options.displayName, options.introduction);
+    if (res.ok) {
+        console.log(`频道 #${name} 创建成功`);
+    }
+    else {
+        console.error(`创建失败: ${res.error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/dm.d.ts

@@ -0,0 +1,10 @@
+export declare function dmSendCommand(handler: string, body: string, options: {
+    author?: string;
+    replyTo?: string;
+}): Promise<void>;
+export declare function dmReadCommand(handler: string, options: {
+    author?: string;
+    limit?: string;
+    since?: string;
+}): Promise<void>;
+export declare function dmListCommand(): Promise<void>;

package/dist/commands/dm.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+function resolveAuthor(repoRoot, explicit) {
+    if (explicit)
+        return explicit;
+    const mePath = path.join(repoRoot, '.gitim', 'me.json');
+    if (fs.existsSync(mePath)) {
+        const me = JSON.parse(fs.readFileSync(mePath, 'utf-8'));
+        return me.handler;
+    }
+    console.error('Error: 未配置身份，请先运行 gitim onboard');
+    process.exit(1);
+}
+export async function dmSendCommand(handler, body, options) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    const author = resolveAuthor(repoRoot, options.author);
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const [h1, h2] = [author, handler].sort();
+    const channel = `dm:${h1},${h2}`;
+    const replyTo = options.replyTo ? parseInt(options.replyTo, 10) : undefined;
+    const res = await client.send(channel, body, author, replyTo);
+    if (res.ok) {
+        console.log('DM sent.');
+    }
+    else {
+        console.error('Error:', res.error);
+    }
+}
+export async function dmReadCommand(handler, options) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    const author = resolveAuthor(repoRoot, options.author);
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const [h1, h2] = [author, handler].sort();
+    const channel = `dm:${h1},${h2}`;
+    const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+    const since = options.since ? parseInt(options.since, 10) : undefined;
+    const res = await client.read(channel, limit, since);
+    if (res.ok) {
+        console.log(JSON.stringify(res.data, null, 2));
+    }
+    else {
+        console.error('Error:', res.error);
+    }
+}
+export async function dmListCommand() {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    // List DM files by scanning dm/ directory
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const dmDir = path.join(repoRoot, 'dm');
+    if (!fs.existsSync(dmDir)) {
+        console.log('No DM conversations.');
+        return;
+    }
+    const files = fs.readdirSync(dmDir).filter((f) => f.endsWith('.thread'));
+    const conversations = files.map((f) => f.replace('.thread', ''));
+    if (conversations.length === 0) {
+        console.log('No DM conversations.');
+    }
+    else {
+        for (const conv of conversations) {
+            console.log(conv);
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initRepo(dir?: string): void;

package/dist/commands/init.js

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function initRepo(dir = process.cwd()) {
+    const dirs = [
+        path.join(dir, '.gitim'),
+        path.join(dir, 'users'),
+        path.join(dir, 'channels'),
+    ];
+    for (const d of dirs) {
+        fs.mkdirSync(d, { recursive: true });
+    }
+    const configPath = path.join(dir, '.gitim', 'config.yaml');
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, 'version: 1\n');
+    }
+    const gitignorePath = path.join(dir, '.gitignore');
+    const gitignoreContent = fs.existsSync(gitignorePath)
+        ? fs.readFileSync(gitignorePath, 'utf-8')
+        : '';
+    if (!gitignoreContent.includes('.gitim/run/')) {
+        fs.appendFileSync(gitignorePath, '\n.gitim/run/\n');
+    }
+    console.log('GitIM repository initialized.');
+}

package/dist/commands/join-channel.d.ts

@@ -0,0 +1,3 @@
+export declare function joinChannelCommand(channel: string, options: {
+    targets?: string[];
+}): Promise<void>;

package/dist/commands/join-channel.js

@@ -0,0 +1,20 @@
+import { findRepoRoot, ensureDaemon } from '../daemon.js';
+import { GitimClient } from '../client.js';
+export async function joinChannelCommand(channel, options) {
+    const repoRoot = findRepoRoot();
+    if (!repoRoot) {
+        console.error('Not in a GitIM repository');
+        process.exit(1);
+    }
+    await ensureDaemon(repoRoot);
+    const client = new GitimClient(repoRoot);
+    const res = await client.joinChannel(channel, options.targets);
+    if (res.ok) {
+        const who = options.targets?.length ? options.targets.join(', ') : '你';
+        console.log(`${who} 已加入 #${channel}`);
+    }
+    else {
+        console.error(`加入失败: ${res.error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/onboard.d.ts

@@ -0,0 +1,17 @@
+type GitServer = 'git' | 'github' | 'gitea' | 'gitlab';
+interface OnboardOptions {
+    gitServer: GitServer;
+    token?: string;
+    handler?: string;
+    displayName?: string;
+    url?: string;
+    refresh?: boolean;
+    debugHttp?: boolean;
+    withWebui?: boolean;
+    webuiPort?: string;
+    webuiDev?: boolean;
+    admin?: boolean;
+    guest?: boolean;
+}
+export declare function onboardCommand(repoName: string | undefined, org: string | undefined, options: OnboardOptions): Promise<void>;
+export {};

package/dist/commands/onboard.js

@@ -0,0 +1,261 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDaemon, isDaemonRunning } from '../daemon.js';
+import { GitimClient } from '../client.js';
+import { startServer } from '../webui/server.js';
+function buildAuth(gitServer, options) {
+    if (gitServer === 'git') {
+        return {
+            handler: options.handler,
+            display_name: options.displayName,
+        };
+    }
+    const auth = { token: options.token };
+    if ((gitServer === 'gitea' || gitServer === 'gitlab') && options.url) {
+        auth.url = options.url;
+    }
+    return auth;
+}
+function ensureConfigDebugHttp(repoDir, enabled) {
+    const configPath = path.join(repoDir, '.gitim', 'config.yaml');
+    if (fs.existsSync(configPath)) {
+        let content = fs.readFileSync(configPath, 'utf-8');
+        if (content.includes('debug_http:')) {
+            content = content.replace(/debug_http:\s*(true|false)/, `debug_http: ${enabled}`);
+        }
+        else if (content.includes('daemon:')) {
+            content = content.replace(/daemon:/, `daemon:\n  debug_http: ${enabled}`);
+        }
+        else {
+            content += `\ndaemon:\n  debug_http: ${enabled}\n`;
+        }
+        fs.writeFileSync(configPath, content);
+    }
+    else {
+        fs.mkdirSync(path.join(repoDir, '.gitim'), { recursive: true });
+        fs.writeFileSync(configPath, `version: 1\ndaemon:\n  debug_http: ${enabled}\n`);
+    }
+}
+function validateParams(gitServer, options) {
+    if (gitServer === 'git') {
+        if (!options.handler) {
+            console.error('Error: git 本地模式需要 --handler');
+            process.exit(1);
+        }
+        if (!options.displayName) {
+            console.error('Error: git 本地模式需要 --display-name');
+            process.exit(1);
+        }
+    }
+    else {
+        if (!options.token) {
+            console.error(`Error: ${gitServer} 模式需要 --token`);
+            process.exit(1);
+        }
+        if ((gitServer === 'gitea' || gitServer === 'gitlab') && !options.url) {
+            console.error(`Error: ${gitServer} 模式需要 --url（服务地址）`);
+            process.exit(1);
+        }
+    }
+}
+function cloneOrCreateRepo(repoName, org, gitServer, options) {
+    const targetDir = path.resolve(repoName);
+    // Determine repo URL (not applicable for plain git local mode)
+    if (gitServer === 'git') {
+        // Local mode: just create directory + git init
+        fs.mkdirSync(targetDir, { recursive: true });
+        try {
+            execFileSync('git', ['init'], { cwd: targetDir, stdio: 'ignore' });
+        }
+        catch {
+            console.error('Error: git init 失败');
+            process.exit(1);
+        }
+        return targetDir;
+    }
+    // Try clone first, then create if needed
+    let cloneSucceeded = false;
+    if (gitServer === 'github') {
+        // GitHub: use gh CLI which resolves owner automatically
+        const ghTarget = org ? `${org}/${repoName}` : repoName;
+        try {
+            execFileSync('gh', ['repo', 'clone', ghTarget, targetDir], { stdio: 'ignore' });
+            cloneSucceeded = true;
+        }
+        catch {
+            cloneSucceeded = false;
+        }
+        if (!cloneSucceeded) {
+            try {
+                execFileSync('gh', ['repo', 'create', ghTarget, '--private', '--clone'], {
+                    cwd: path.dirname(targetDir),
+                    stdio: 'ignore',
+                });
+            }
+            catch {
+                console.error(`Error: 无法创建仓库 ${ghTarget}`);
+                console.error('  → 请确认 gh 已认证且 Token 有仓库创建权限');
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        // Gitea / GitLab: org is required for URL construction
+        if (!org) {
+            console.error(`Error: ${gitServer} 模式需要指定 org（作为 URL 中的 owner）`);
+            console.error('  → 用法: gitim onboard <repo> <org> --git-server gitea --url ...');
+            process.exit(1);
+        }
+        const baseUrl = options.url;
+        const repoUrl = `${baseUrl}/${org}/${repoName}.git`;
+        try {
+            execFileSync('git', ['clone', repoUrl, targetDir], { stdio: 'ignore' });
+            cloneSucceeded = true;
+        }
+        catch {
+            cloneSucceeded = false;
+        }
+        if (!cloneSucceeded) {
+            if (gitServer === 'gitlab') {
+                console.error('Error: GitLab 不支持自动创建仓库，请先在 GitLab 上手动创建');
+                console.error(`  → 创建后再运行: gitim onboard ${repoName} ${org} --git-server gitlab --url ${baseUrl} --token ...`);
+                process.exit(1);
+            }
+            // Gitea: create via API then clone
+            const token = options.token;
+            const createUrl = `${baseUrl}/api/v1/orgs/${org}/repos`;
+            try {
+                execFileSync('curl', [
+                    '-sf', '-X', 'POST',
+                    '-H', `Authorization: token ${token}`,
+                    '-H', 'Content-Type: application/json',
+                    '-d', JSON.stringify({ name: repoName, private: true }),
+                    createUrl,
+                ], { stdio: 'ignore' });
+                execFileSync('git', ['clone', repoUrl, targetDir], { stdio: 'ignore' });
+            }
+            catch {
+                console.error(`Error: 无法创建 Gitea 仓库 ${repoName}`);
+                process.exit(1);
+            }
+        }
+    }
+    return targetDir;
+}
+export async function onboardCommand(repoName, org, options) {
+    const gitServer = (options.gitServer || 'github');
+    // --guest 和 --admin 互斥
+    if (options.guest && options.admin) {
+        console.error('Error: --guest 和 --admin 不能同时使用');
+        process.exit(1);
+    }
+    // --refresh mode: send Onboard request to running daemon
+    if (options.refresh) {
+        if (!options.guest) {
+            validateParams(gitServer, options);
+        }
+        const cwd = process.cwd();
+        const gitimDir = path.join(cwd, '.gitim');
+        if (!fs.existsSync(gitimDir)) {
+            console.error('不在 GitIM 仓库中，无法 --refresh');
+            process.exit(1);
+        }
+        // If --debug-http is set, update config and restart daemon
+        if (options.debugHttp) {
+            ensureConfigDebugHttp(cwd, true);
+            if (isDaemonRunning(cwd)) {
+                const oldClient = new GitimClient(cwd);
+                await oldClient.stop().catch(() => { });
+                // Wait briefly for daemon to exit
+                await new Promise((r) => setTimeout(r, 300));
+            }
+        }
+        await ensureDaemon(cwd);
+        const client = new GitimClient(cwd);
+        const auth = options.guest ? {} : buildAuth(gitServer, options);
+        const res = await client.onboard(gitServer, auth, options.admin, options.guest);
+        if (!res.ok) {
+            console.error(`身份刷新失败：${res.error}`);
+            process.exit(1);
+        }
+        if (options.guest) {
+            console.log('游客模式已刷新');
+        }
+        else {
+            const adminTag = options.admin ? ' [ADMIN]' : '';
+            console.log(`身份已刷新：@${res.data?.handler}${adminTag}`);
+        }
+        if (options.withWebui) {
+            await launchWebui(cwd, options);
+        }
+        return;
+    }
+    if (!repoName) {
+        console.error('请指定仓库名称: gitim onboard <repo_name> [org]');
+        process.exit(1);
+    }
+    // 1. Validate params
+    if (!options.guest) {
+        validateParams(gitServer, options);
+    }
+    // 2. Clone or create repo
+    const repoDir = cloneOrCreateRepo(repoName, org, gitServer, options);
+    // 3. Ensure .gitim/ directory exists
+    fs.mkdirSync(path.join(repoDir, '.gitim'), { recursive: true });
+    // 3.5. Write config with debug_http if requested (before daemon starts)
+    if (options.debugHttp) {
+        ensureConfigDebugHttp(repoDir, true);
+    }
+    // 4. Start daemon
+    await ensureDaemon(repoDir);
+    // 5. Send Onboard request
+    const client = new GitimClient(repoDir);
+    const auth = options.guest ? {} : buildAuth(gitServer, options);
+    const res = await client.onboard(gitServer, auth, options.admin, options.guest);
+    if (!res.ok) {
+        console.error(`Onboard 失败：${res.error}`);
+        process.exit(1);
+    }
+    // 6. Report result
+    if (options.guest) {
+        console.log(`游客模式已启动 @ ${repoName}`);
+    }
+    else {
+        const handler = res.data?.handler ?? '(unknown)';
+        const created = res.data?.created ? '（新建）' : '（已加入）';
+        const adminTag = options.admin ? ' [ADMIN]' : '';
+        console.log(`成功 ${created}：@${handler}${adminTag} @ ${repoName}`);
+    }
+    // 7. Optional: start WebUI
+    if (options.withWebui) {
+        await launchWebui(repoDir, options);
+    }
+}
+async function launchWebui(repoDir, options) {
+    const port = parseInt(options.webuiPort || '6868', 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error('错误：--webui-port 必须是 1-65535 之间的数字');
+        process.exit(1);
+    }
+    const dev = options.webuiDev || false;
+    try {
+        await startServer({ repoRoot: repoDir, port, dev });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes('already in use')) {
+            console.error(`错误：端口 ${port} 已被占用`);
+            console.error('  → 使用 --webui-port <port> 指定其他端口');
+        }
+        else {
+            console.error(`错误：无法启动 WebUI — ${msg}`);
+        }
+        process.exit(1);
+    }
+    // HTTP server 保持进程运行，Ctrl+C 干净退出
+    process.on('SIGINT', () => {
+        console.log('\n正在关闭 WebUI...');
+        process.exit(0);
+    });
+}

package/dist/commands/read.d.ts

@@ -0,0 +1,4 @@
+export declare function readCommand(channel: string, options: {
+    limit?: string;
+    since?: string;
+}): Promise<void>;