@next-open-ai/openclawx 0.6.6

package/dist/server/tasks/tasks.service.d.ts

@@ -0,0 +1,86 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service.js';
+import { AgentsService } from '../agents/agents.service.js';
+import { ConfigService } from '../config/config.service.js';
+import { UsageService } from '../usage/usage.service.js';
+export type ScheduleType = 'once' | 'cron';
+export interface RepeatRule {
+    type: 'daily' | 'weekdays' | 'weekends' | 'weekly' | 'monthly';
+    time: string;
+    days?: number[];
+    dayOfMonth?: number;
+}
+export interface ScheduledTask {
+    id: string;
+    workspace: string;
+    message: string;
+    scheduleType: ScheduleType;
+    runAt?: number;
+    cronExpr?: string;
+    repeatRuleJson?: string;
+    enabled: boolean;
+    lastRunAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export type TaskExecutionStatus = 'success' | 'failed';
+export interface TaskExecution {
+    id: string;
+    taskId: string;
+    ranAt: number;
+    status: TaskExecutionStatus;
+    sessionId?: string;
+    userMessage: string;
+    assistantContent?: string;
+    errorMessage?: string;
+    createdAt: number;
+}
+/** 将 repeatRule 转为 cron 表达式 */
+export declare function repeatRuleToCron(rule: RepeatRule): string;
+export declare class TasksService implements OnModuleInit, OnModuleDestroy {
+    private readonly db;
+    private readonly agentsService;
+    private readonly configService;
+    private readonly usageService;
+    private tickTimer;
+    private readonly TICK_MS;
+    /** 正在执行中的 task id，避免同一任务在两次 tick 中并发执行 */
+    private runningTaskIds;
+    constructor(db: DatabaseService, agentsService: AgentsService, configService: ConfigService, usageService: UsageService);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    private rowToTask;
+    list(): ScheduledTask[];
+    get(id: string): ScheduledTask | null;
+    private rowToExecution;
+    addExecution(params: {
+        taskId: string;
+        ranAt: number;
+        status: TaskExecutionStatus;
+        sessionId?: string;
+        userMessage: string;
+        assistantContent?: string;
+        errorMessage?: string;
+    }): TaskExecution;
+    listExecutions(taskId: string): TaskExecution[];
+    getExecution(id: string): TaskExecution | null;
+    /** 删除指定任务的全部执行记录，返回删除条数 */
+    deleteExecutionsByTaskId(taskId: string): number;
+    create(params: {
+        workspace: string;
+        message: string;
+        scheduleType: ScheduleType;
+        runAt?: number;
+        cronExpr?: string;
+        repeatRule?: RepeatRule;
+    }): ScheduledTask;
+    update(id: string, updates: Partial<Pick<ScheduledTask, 'message' | 'enabled' | 'scheduleType' | 'runAt' | 'cronExpr' | 'repeatRuleJson'>>): ScheduledTask | null;
+    delete(id: string): boolean;
+    /** 获取当前应执行的任务 */
+    getDueTasks(at: Date): ScheduledTask[];
+    /** 仅更新 last_run_at，不关单次任务。用于「开始执行」时立即占位，避免下一分钟 tick 重复触发同一任务。 */
+    markRunStarted(id: string): void;
+    markRan(id: string): void;
+    /** 每分钟触发：拉取到点任务，创建会话、写用户消息、请求 Gateway 执行，写执行记录，再 markRan */
+    private tick;
+}

package/dist/server/tasks/tasks.service.js

@@ -0,0 +1,327 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { randomUUID } from 'crypto';
+import { Cron } from 'croner';
+import { DatabaseService } from '../database/database.service.js';
+import { AgentsService } from '../agents/agents.service.js';
+import { ConfigService } from '../config/config.service.js';
+import { UsageService } from '../usage/usage.service.js';
+/** 将 repeatRule 转为 cron 表达式 */
+export function repeatRuleToCron(rule) {
+    const [h, m] = rule.time.split(':').map(Number);
+    const minute = m ?? 0;
+    const hour = h ?? 9;
+    const timePart = `${minute} ${hour} * *`;
+    switch (rule.type) {
+        case 'daily':
+            return `${minute} ${hour} * * *`;
+        case 'weekdays':
+            return `${minute} ${hour} * * 1-5`;
+        case 'weekends':
+            return `${minute} ${hour} * * 0,6`;
+        case 'weekly':
+            if (rule.days?.length) {
+                return `${minute} ${hour} * * ${rule.days.sort((a, b) => a - b).join(',')}`;
+            }
+            return `${minute} ${hour} * * *`;
+        case 'monthly': {
+            const day = Math.min(rule.dayOfMonth ?? 1, 31);
+            return `${minute} ${hour} ${day} * *`;
+        }
+        default:
+            return `${minute} ${hour} * * *`;
+    }
+}
+let TasksService = class TasksService {
+    db;
+    agentsService;
+    configService;
+    usageService;
+    tickTimer = null;
+    TICK_MS = 60 * 1000;
+    /** 正在执行中的 task id，避免同一任务在两次 tick 中并发执行 */
+    runningTaskIds = new Set();
+    constructor(db, agentsService, configService, usageService) {
+        this.db = db;
+        this.agentsService = agentsService;
+        this.configService = configService;
+        this.usageService = usageService;
+    }
+    onModuleInit() {
+        this.tickTimer = setInterval(() => this.tick(), this.TICK_MS);
+    }
+    onModuleDestroy() {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+    }
+    rowToTask(r) {
+        return {
+            id: r.id,
+            workspace: r.workspace,
+            message: r.message,
+            scheduleType: r.schedule_type,
+            runAt: r.run_at ?? undefined,
+            cronExpr: r.cron_expr ?? undefined,
+            repeatRuleJson: r.repeat_rule_json ?? undefined,
+            enabled: r.enabled === 1,
+            lastRunAt: r.last_run_at ?? undefined,
+            createdAt: r.created_at,
+            updatedAt: r.updated_at,
+        };
+    }
+    list() {
+        const rows = this.db.all('SELECT * FROM scheduled_tasks ORDER BY created_at DESC');
+        return rows.map((r) => this.rowToTask(r));
+    }
+    get(id) {
+        const r = this.db.get('SELECT * FROM scheduled_tasks WHERE id = ?', [id]);
+        return r ? this.rowToTask(r) : null;
+    }
+    rowToExecution(r) {
+        return {
+            id: r.id,
+            taskId: r.task_id,
+            ranAt: r.ran_at,
+            status: r.status,
+            sessionId: r.session_id ?? undefined,
+            userMessage: r.user_message,
+            assistantContent: r.assistant_content ?? undefined,
+            errorMessage: r.error_message ?? undefined,
+            createdAt: r.created_at,
+        };
+    }
+    addExecution(params) {
+        const id = randomUUID();
+        const now = Date.now();
+        this.db.run(`INSERT INTO scheduled_task_executions (id, task_id, ran_at, status, session_id, user_message, assistant_content, error_message, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            id,
+            params.taskId,
+            params.ranAt,
+            params.status,
+            params.sessionId ?? null,
+            params.userMessage,
+            params.assistantContent ?? null,
+            params.errorMessage ?? null,
+            now,
+        ]);
+        return this.getExecution(id);
+    }
+    listExecutions(taskId) {
+        const rows = this.db.all('SELECT * FROM scheduled_task_executions WHERE task_id = ? ORDER BY ran_at DESC', [taskId]);
+        return rows.map((r) => this.rowToExecution(r));
+    }
+    getExecution(id) {
+        const r = this.db.get('SELECT * FROM scheduled_task_executions WHERE id = ?', [id]);
+        return r ? this.rowToExecution(r) : null;
+    }
+    /** 删除指定任务的全部执行记录，返回删除条数 */
+    deleteExecutionsByTaskId(taskId) {
+        const result = this.db.run('DELETE FROM scheduled_task_executions WHERE task_id = ?', [taskId]);
+        return result.changes;
+    }
+    create(params) {
+        const id = randomUUID();
+        const now = Date.now();
+        let cronExpr = params.cronExpr ?? null;
+        let runAt = params.runAt ?? null;
+        if (params.scheduleType === 'cron' && params.repeatRule && !cronExpr) {
+            cronExpr = repeatRuleToCron(params.repeatRule);
+        }
+        const repeatRuleJson = params.repeatRule
+            ? JSON.stringify(params.repeatRule)
+            : null;
+        this.db.run(`INSERT INTO scheduled_tasks (id, workspace, message, schedule_type, run_at, cron_expr, repeat_rule_json, enabled, last_run_at, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, 1, NULL, ?, ?)`, [
+            id,
+            params.workspace,
+            params.message,
+            params.scheduleType,
+            runAt,
+            cronExpr,
+            repeatRuleJson,
+            now,
+            now,
+        ]);
+        const task = this.get(id);
+        return task;
+    }
+    update(id, updates) {
+        const task = this.get(id);
+        if (!task)
+            return null;
+        const now = Date.now();
+        const message = updates.message ?? task.message;
+        const enabled = updates.enabled !== undefined ? (updates.enabled ? 1 : 0) : (task.enabled ? 1 : 0);
+        const scheduleType = (updates.scheduleType ?? task.scheduleType);
+        const runAt = scheduleType === 'once'
+            ? (updates.runAt ?? task.runAt ?? null)
+            : null;
+        const cronExpr = scheduleType === 'cron'
+            ? (updates.cronExpr ?? task.cronExpr ?? null)
+            : null;
+        const repeatRuleJson = scheduleType === 'cron'
+            ? (updates.repeatRuleJson ?? task.repeatRuleJson ?? null)
+            : null;
+        this.db.run(`UPDATE scheduled_tasks SET message = ?, enabled = ?, schedule_type = ?, run_at = ?, cron_expr = ?, repeat_rule_json = ?, updated_at = ? WHERE id = ?`, [message, enabled, scheduleType, runAt, cronExpr, repeatRuleJson, now, id]);
+        return this.get(id);
+    }
+    delete(id) {
+        const result = this.db.run('DELETE FROM scheduled_tasks WHERE id = ?', [id]);
+        return result.changes > 0;
+    }
+    /** 获取当前应执行的任务 */
+    getDueTasks(at) {
+        const atMs = at.getTime();
+        const rows = this.db.all('SELECT * FROM scheduled_tasks WHERE enabled = 1');
+        const due = [];
+        for (const r of rows) {
+            const task = this.rowToTask(r);
+            if (task.scheduleType === 'once') {
+                // 单次：到点且尚未执行过（markRunStarted 会设 last_run_at，避免重复触发）
+                if (task.runAt != null && task.runAt <= atMs && task.lastRunAt == null) {
+                    due.push(task);
+                }
+            }
+            else if (task.cronExpr) {
+                try {
+                    const cron = new Cron(task.cronExpr);
+                    const ref = new Date(atMs - 2 * this.TICK_MS);
+                    const next = cron.nextRun(ref);
+                    const nextMs = next?.getTime();
+                    // 仅当「本周期」尚未执行过才加入；且要求触发点已到（nextMs <= atMs），避免把下一分钟算进当前
+                    const notYetRunForThisOccurrence = task.lastRunAt == null || (nextMs != null && task.lastRunAt < nextMs);
+                    const scheduledTimeHasPassed = nextMs != null && nextMs <= atMs;
+                    const inCurrentTickWindow = nextMs != null && nextMs >= atMs - this.TICK_MS;
+                    if (scheduledTimeHasPassed && inCurrentTickWindow && notYetRunForThisOccurrence) {
+                        due.push(task);
+                    }
+                }
+                catch {
+                    // invalid cron, skip
+                }
+            }
+        }
+        return due;
+    }
+    /** 仅更新 last_run_at，不关单次任务。用于「开始执行」时立即占位，避免下一分钟 tick 重复触发同一任务。 */
+    markRunStarted(id) {
+        const now = Date.now();
+        this.db.run('UPDATE scheduled_tasks SET last_run_at = ?, updated_at = ? WHERE id = ?', [now, now, id]);
+    }
+    markRan(id) {
+        const now = Date.now();
+        const task = this.get(id);
+        if (!task)
+            return;
+        if (task.scheduleType === 'once') {
+            this.db.run('UPDATE scheduled_tasks SET last_run_at = ?, enabled = 0, updated_at = ? WHERE id = ?', [now, now, id]);
+        }
+        else {
+            this.db.run('UPDATE scheduled_tasks SET last_run_at = ?, updated_at = ? WHERE id = ?', [now, now, id]);
+        }
+    }
+    /** 每分钟触发：拉取到点任务，创建会话、写用户消息、请求 Gateway 执行，写执行记录，再 markRan */
+    async tick() {
+        const now = new Date();
+        const nowMs = now.getTime();
+        const due = this.getDueTasks(now);
+        if (due.length === 0)
+            return;
+        const config = await this.configService.getConfig();
+        const gatewayBase = config.gatewayUrl.replace(/^ws:/, 'http:').replace(/^wss:/, 'https:');
+        for (const task of due) {
+            if (this.runningTaskIds.has(task.id))
+                continue;
+            this.runningTaskIds.add(task.id);
+            const fixedSessionId = `scheduled-${task.id}`;
+            // 立即更新 last_run_at，避免执行期间下一分钟 tick 再次把本任务判为 due 导致重复请求
+            this.markRunStarted(task.id);
+            try {
+                const session = await this.agentsService.getOrCreateSession(fixedSessionId, {
+                    agentId: task.workspace,
+                    workspace: task.workspace,
+                    title: `定时: ${task.message.slice(0, 30)}${task.message.length > 30 ? '…' : ''}`,
+                    type: 'scheduled',
+                });
+                this.agentsService.appendMessage(session.id, 'user', task.message);
+                // Agent 可能执行很久（如浏览器操作），需放宽超时，否则 undici 会报 HeadersTimeoutError
+                const runTimeoutMs = 10 * 60 * 1000; // 10 分钟
+                const res = await fetch(`${gatewayBase}/run-scheduled-task`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        sessionId: fixedSessionId,
+                        message: task.message,
+                        agentId: session.agentId ?? task.workspace,
+                        workspace: task.workspace,
+                        taskId: task.id,
+                        backendBaseUrl: `http://localhost:${process.env.PORT || 38081}`,
+                    }),
+                    signal: AbortSignal.timeout(runTimeoutMs),
+                });
+                const body = await res.json().catch(() => ({}));
+                const assistantContent = body.assistantContent ?? '';
+                const ok = res.ok && body.success !== false;
+                if (ok && body.usage && (body.usage.promptTokens > 0 || body.usage.completionTokens > 0)) {
+                    this.usageService.recordUsage({
+                        sessionId: fixedSessionId,
+                        source: 'scheduled_task',
+                        taskId: task.id,
+                        promptTokens: body.usage.promptTokens ?? 0,
+                        completionTokens: body.usage.completionTokens ?? 0,
+                    });
+                }
+                const execution = this.addExecution({
+                    taskId: task.id,
+                    ranAt: nowMs,
+                    status: ok ? 'success' : 'failed',
+                    sessionId: fixedSessionId,
+                    userMessage: task.message,
+                    assistantContent: ok ? assistantContent : undefined,
+                    errorMessage: ok ? undefined : (body.error || `HTTP ${res.status}`),
+                });
+                if (ok) {
+                    console.log(`[Tasks] 任务执行完成: ${task.id} (执行记录 ${execution.id})`);
+                    this.markRan(task.id);
+                }
+                else {
+                    console.error(`[Tasks] run-scheduled-task failed for ${task.id}: ${body.error || res.status}`);
+                }
+            }
+            catch (e) {
+                const errMsg = e?.message ?? String(e);
+                this.addExecution({
+                    taskId: task.id,
+                    ranAt: nowMs,
+                    status: 'failed',
+                    sessionId: fixedSessionId,
+                    userMessage: task.message,
+                    errorMessage: errMsg,
+                });
+                console.error(`[Tasks] tick task ${task.id} error:`, e);
+            }
+            finally {
+                this.runningTaskIds.delete(task.id);
+            }
+        }
+    }
+};
+TasksService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService,
+        AgentsService,
+        ConfigService,
+        UsageService])
+], TasksService);
+export { TasksService };

package/dist/server/usage/usage.controller.d.ts

@@ -0,0 +1,12 @@
+import { UsageService, RecordTokenUsageDto, TokenUsageTotal } from './usage.service.js';
+export declare class UsageController {
+    private readonly usageService;
+    constructor(usageService: UsageService);
+    record(dto: RecordTokenUsageDto): {
+        success: boolean;
+    };
+    getTotal(): {
+        success: boolean;
+        data: TokenUsageTotal;
+    };
+}

package/dist/server/usage/usage.controller.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { UsageService } from './usage.service.js';
+let UsageController = class UsageController {
+    usageService;
+    constructor(usageService) {
+        this.usageService = usageService;
+    }
+    record(dto) {
+        this.usageService.recordUsage(dto);
+        return { success: true };
+    }
+    getTotal() {
+        const data = this.usageService.getTotal();
+        return { success: true, data };
+    }
+};
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], UsageController.prototype, "record", null);
+__decorate([
+    Get('total'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], UsageController.prototype, "getTotal", null);
+UsageController = __decorate([
+    Controller('usage'),
+    __metadata("design:paramtypes", [UsageService])
+], UsageController);
+export { UsageController };

package/dist/server/usage/usage.module.d.ts

@@ -0,0 +1,2 @@
+export declare class UsageModule {
+}

package/dist/server/usage/usage.module.js

@@ -0,0 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { UsageService } from './usage.service.js';
+import { UsageController } from './usage.controller.js';
+let UsageModule = class UsageModule {
+};
+UsageModule = __decorate([
+    Module({
+        controllers: [UsageController],
+        providers: [UsageService],
+        exports: [UsageService],
+    })
+], UsageModule);
+export { UsageModule };

package/dist/server/usage/usage.service.d.ts

@@ -0,0 +1,21 @@
+import { DatabaseService } from '../database/database.service.js';
+export type TokenUsageSource = 'chat' | 'scheduled_task';
+export interface RecordTokenUsageDto {
+    sessionId: string;
+    source: TokenUsageSource;
+    taskId?: string;
+    executionId?: string;
+    promptTokens: number;
+    completionTokens: number;
+}
+export interface TokenUsageTotal {
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+}
+export declare class UsageService {
+    private readonly db;
+    constructor(db: DatabaseService);
+    recordUsage(dto: RecordTokenUsageDto): void;
+    getTotal(): TokenUsageTotal;
+}

package/dist/server/usage/usage.service.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { randomUUID } from 'crypto';
+import { DatabaseService } from '../database/database.service.js';
+let UsageService = class UsageService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    recordUsage(dto) {
+        const total = (dto.promptTokens || 0) + (dto.completionTokens || 0);
+        if (total <= 0)
+            return;
+        this.db.run(`INSERT INTO token_usage (id, session_id, source, task_id, execution_id, prompt_tokens, completion_tokens, total_tokens, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            randomUUID(),
+            dto.sessionId,
+            dto.source,
+            dto.taskId ?? null,
+            dto.executionId ?? null,
+            dto.promptTokens ?? 0,
+            dto.completionTokens ?? 0,
+            total,
+            Date.now(),
+        ]);
+    }
+    getTotal() {
+        const row = this.db.get(`SELECT
+               COALESCE(SUM(prompt_tokens), 0) AS total_prompt,
+               COALESCE(SUM(completion_tokens), 0) AS total_completion,
+               COALESCE(SUM(total_tokens), 0) AS total_tokens
+             FROM token_usage`);
+        if (!row) {
+            return { totalPromptTokens: 0, totalCompletionTokens: 0, totalTokens: 0 };
+        }
+        return {
+            totalPromptTokens: row.total_prompt,
+            totalCompletionTokens: row.total_completion,
+            totalTokens: row.total_tokens,
+        };
+    }
+};
+UsageService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService])
+], UsageService);
+export { UsageService };

package/dist/server/users/users.controller.d.ts

@@ -0,0 +1,35 @@
+import { UsersService } from './users.service.js';
+export declare class UsersController {
+    private readonly usersService;
+    constructor(usersService: UsersService);
+    list(): Promise<{
+        success: boolean;
+        data: {
+            id: string;
+            username: string;
+        }[];
+    }>;
+    create(body: {
+        username: string;
+        password: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            id: string;
+            username: string;
+        };
+    }>;
+    update(id: string, body: {
+        username?: string;
+        password?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            id: string;
+            username: string;
+        };
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/server/users/users.controller.js

@@ -0,0 +1,69 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
+import { UsersService } from './users.service.js';
+let UsersController = class UsersController {
+    usersService;
+    constructor(usersService) {
+        this.usersService = usersService;
+    }
+    async list() {
+        const users = await this.usersService.list();
+        return { success: true, data: users };
+    }
+    async create(body) {
+        const user = await this.usersService.create(body.username ?? '', body.password ?? '');
+        return { success: true, data: user };
+    }
+    async update(id, body) {
+        const user = await this.usersService.update(id, body);
+        return { success: true, data: user };
+    }
+    async delete(id) {
+        await this.usersService.delete(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "list", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "create", null);
+__decorate([
+    Put(':id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "update", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UsersController.prototype, "delete", null);
+UsersController = __decorate([
+    Controller('users'),
+    __metadata("design:paramtypes", [UsersService])
+], UsersController);
+export { UsersController };