forge-openclaw-plugin 0.2.3 → 0.2.7

package/dist/server/db.js

@@ -0,0 +1,313 @@
+import { mkdir, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+function nowIso() {
+    return new Date().toISOString();
+}
+function dateOffsetIso(days) {
+    const date = new Date();
+    date.setUTCDate(date.getUTCDate() + days);
+    return date.toISOString().slice(0, 10);
+}
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const migrationsDir = path.join(projectRoot, "server", "migrations");
+let dataRoot = process.cwd();
+let seedDemoDataEnabled = false;
+let db = null;
+let transactionDepth = 0;
+let savepointCounter = 0;
+function getDataDir() {
+    return path.join(dataRoot, "data");
+}
+function getDatabasePath() {
+    return path.join(getDataDir(), "forge.sqlite");
+}
+export function getDatabase() {
+    if (!db) {
+        db = new DatabaseSync(getDatabasePath());
+        db.exec("PRAGMA foreign_keys = ON;");
+        db.exec("PRAGMA busy_timeout = 5000;");
+        db.exec("PRAGMA synchronous = FULL;");
+        db.prepare("PRAGMA journal_mode = WAL;").get();
+    }
+    return db;
+}
+export function runInTransaction(operation) {
+    const database = getDatabase();
+    const isNested = transactionDepth > 0;
+    const savepointName = isNested ? `forge_sp_${++savepointCounter}` : null;
+    if (isNested) {
+        database.exec(`SAVEPOINT ${savepointName}`);
+    }
+    else {
+        database.exec("BEGIN IMMEDIATE");
+    }
+    transactionDepth += 1;
+    try {
+        const result = operation();
+        if (isNested) {
+            database.exec(`RELEASE SAVEPOINT ${savepointName}`);
+        }
+        else {
+            database.exec("COMMIT");
+        }
+        return result;
+    }
+    catch (error) {
+        if (isNested) {
+            database.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+            database.exec(`RELEASE SAVEPOINT ${savepointName}`);
+        }
+        else {
+            database.exec("ROLLBACK");
+        }
+        throw error;
+    }
+    finally {
+        transactionDepth = Math.max(0, transactionDepth - 1);
+    }
+}
+export function configureDatabase(options = {}) {
+    if (options.dataRoot) {
+        dataRoot = path.resolve(options.dataRoot);
+        closeDatabase();
+    }
+    if (typeof options.seedDemoData === "boolean") {
+        seedDemoDataEnabled = options.seedDemoData;
+    }
+}
+async function listMigrationFiles() {
+    const files = await readdir(migrationsDir);
+    return files.filter((file) => file.endsWith(".sql")).sort();
+}
+function countRows(tableName) {
+    const row = getDatabase().prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get();
+    return row.count;
+}
+function seedData() {
+    if (countRows("goals") > 0) {
+        return;
+    }
+    const database = getDatabase();
+    const now = nowIso();
+    const insertGoal = database.prepare(`
+    INSERT INTO goals (id, title, description, horizon, status, target_points, theme_color, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertTag = database.prepare(`
+    INSERT INTO tags (id, name, kind, color, description, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    const insertGoalTag = database.prepare(`
+    INSERT INTO goal_tags (goal_id, tag_id)
+    VALUES (?, ?)
+  `);
+    const insertProject = database.prepare(`
+    INSERT INTO projects (id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertTask = database.prepare(`
+    INSERT INTO tasks (
+      id, title, description, status, priority, owner, goal_id, project_id, due_date, effort, energy, points, sort_order, completed_at, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertTaskTag = database.prepare(`
+    INSERT INTO task_tags (task_id, tag_id)
+    VALUES (?, ?)
+  `);
+    const goals = [
+        {
+            id: "goal_be_a_good_person",
+            title: "Be a good person",
+            description: "Live in a way that is kind, honest, and helpful to other people.",
+            horizon: "lifetime",
+            status: "active",
+            targetPoints: 1000,
+            themeColor: "#f5efe6"
+        },
+        {
+            id: "goal_build_forge",
+            title: "Build Forge into a premium operating system",
+            description: "Turn Forge into a sharp, trustworthy life system with strong daily execution.",
+            horizon: "year",
+            status: "active",
+            targetPoints: 720,
+            themeColor: "#9dc4ff"
+        },
+        {
+            id: "goal_train_body",
+            title: "Train with consistency",
+            description: "Keep health, training, and recovery visible in the weekly operating rhythm.",
+            horizon: "quarter",
+            status: "active",
+            targetPoints: 360,
+            themeColor: "#f4b97a"
+        }
+    ];
+    for (const goal of goals) {
+        insertGoal.run(goal.id, goal.title, goal.description, goal.horizon, goal.status, goal.targetPoints, goal.themeColor, now, now);
+    }
+    const tags = [
+        ["tag_vitality", "Vitality", "value", "#f59e0b", "Health, training, and physical energy."],
+        ["tag_deep_work", "Deep Work", "execution", "#8b5cf6", "Protected focus and cognitively demanding work."],
+        ["tag_relationships", "Relationships", "value", "#ef4444", "Important human connection and maintenance."],
+        ["tag_systems", "Systems", "category", "#14b8a6", "Operational scaffolding, review, and maintenance."],
+        ["tag_craft", "Craft", "category", "#60a5fa", "Making the product sharper and more intentional."],
+        ["tag_recovery", "Recovery", "execution", "#22c55e", "Recovery, decompression, and reset work."]
+    ];
+    for (const [id, name, kind, color, description] of tags) {
+        insertTag.run(id, name, kind, color, description, now);
+    }
+    insertGoalTag.run("goal_be_a_good_person", "tag_relationships");
+    insertGoalTag.run("goal_build_forge", "tag_craft");
+    insertGoalTag.run("goal_build_forge", "tag_systems");
+    insertGoalTag.run("goal_train_body", "tag_vitality");
+    insertGoalTag.run("goal_train_body", "tag_recovery");
+    insertProject.run("project_relationships_ritual", "goal_be_a_good_person", "Keep the relationship ritual visible", "Protect simple weekly actions that maintain important relationships and personal integrity.", "active", "#fb7185", 90, now, now);
+    insertProject.run("project_forge_mobile", "goal_build_forge", "Ship the Forge flagship workflow", "Tighten the main execution loop, Kanban, and OpenClaw collaboration surface.", "active", "#7dd3fc", 240, now, now);
+    insertProject.run("project_strength_cycle", "goal_train_body", "Run the current strength cycle", "Keep the training block visible with recovery and progression.", "active", "#f59e0b", 120, now, now);
+    const tasks = [
+        {
+            id: "task_flagship_review",
+            title: "Review the Forge flagship flow",
+            description: "Walk Overview, Today, Kanban, and Psyche to identify friction before the next pass.",
+            status: "focus",
+            priority: "high",
+            owner: "Albert",
+            goalId: "goal_build_forge",
+            projectId: "project_forge_mobile",
+            dueDate: dateOffsetIso(1),
+            effort: "deep",
+            energy: "high",
+            points: 55,
+            sortOrder: 100,
+            completedAt: null
+        },
+        {
+            id: "task_plugin_surface",
+            title: "Slim the OpenClaw plugin surface",
+            description: "Keep the plugin focused on overview, batch entities, insights, and UI entry.",
+            status: "in_progress",
+            priority: "high",
+            owner: "Albert",
+            goalId: "goal_build_forge",
+            projectId: "project_forge_mobile",
+            dueDate: dateOffsetIso(0),
+            effort: "deep",
+            energy: "high",
+            points: 34,
+            sortOrder: 200,
+            completedAt: null
+        },
+        {
+            id: "task_weekly_review",
+            title: "Prepare the weekly review ritual",
+            description: "Make sure the review captures drift, signals, and visible wins.",
+            status: "backlog",
+            priority: "medium",
+            owner: "Albert",
+            goalId: "goal_be_a_good_person",
+            projectId: "project_relationships_ritual",
+            dueDate: dateOffsetIso(3),
+            effort: "deep",
+            energy: "steady",
+            points: 21,
+            sortOrder: 300,
+            completedAt: null
+        },
+        {
+            id: "task_strength_session",
+            title: "Complete the lower-body strength session",
+            description: "Keep the training cycle alive with one deliberate session.",
+            status: "blocked",
+            priority: "medium",
+            owner: "Albert",
+            goalId: "goal_train_body",
+            projectId: "project_strength_cycle",
+            dueDate: dateOffsetIso(-1),
+            effort: "deep",
+            energy: "steady",
+            points: 18,
+            sortOrder: 400,
+            completedAt: null
+        },
+        {
+            id: "task_recovery_walk",
+            title: "Take the recovery walk",
+            description: "Short reset to keep energy stable after the work block.",
+            status: "done",
+            priority: "low",
+            owner: "Albert",
+            goalId: "goal_train_body",
+            projectId: "project_strength_cycle",
+            dueDate: dateOffsetIso(-2),
+            effort: "light",
+            energy: "low",
+            points: 60,
+            sortOrder: 500,
+            completedAt: now
+        }
+    ];
+    for (const task of tasks) {
+        insertTask.run(task.id, task.title, task.description, task.status, task.priority, task.owner, task.goalId, task.projectId, task.dueDate, task.effort, task.energy, task.points, task.sortOrder, task.completedAt, now, now);
+    }
+    const taskTags = [
+        ["task_flagship_review", "tag_deep_work"],
+        ["task_flagship_review", "tag_craft"],
+        ["task_plugin_surface", "tag_systems"],
+        ["task_plugin_surface", "tag_craft"],
+        ["task_weekly_review", "tag_relationships"],
+        ["task_strength_session", "tag_vitality"],
+        ["task_recovery_walk", "tag_recovery"]
+    ];
+    for (const [taskId, tagId] of taskTags) {
+        insertTaskTag.run(taskId, tagId);
+    }
+}
+export async function initializeDatabase() {
+    await mkdir(getDataDir(), { recursive: true });
+    const database = getDatabase();
+    const migrationFiles = await listMigrationFiles();
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      id TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+    const appliedRows = database
+        .prepare("SELECT id FROM migrations ORDER BY id")
+        .all();
+    const applied = new Set(appliedRows.map((row) => row.id));
+    for (const file of migrationFiles) {
+        if (applied.has(file)) {
+            continue;
+        }
+        const sql = await readFile(path.join(migrationsDir, file), "utf8");
+        database.exec("BEGIN");
+        try {
+            database.exec(sql);
+            database
+                .prepare("INSERT INTO migrations (id, applied_at) VALUES (?, ?)")
+                .run(file, nowIso());
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    if (seedDemoDataEnabled) {
+        seedData();
+    }
+}
+export function configureDatabaseSeeding(enabled) {
+    seedDemoDataEnabled = enabled;
+}
+export function closeDatabase() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/server/e2e-server.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp } from "node:fs/promises";
+import { buildServer } from "./app.js";
+import { closeDatabase } from "./db.js";
+const port = Number(process.env.PORT ?? 4317);
+const host = process.env.HOST ?? "127.0.0.1";
+const dataRoot = process.env.FORGE_E2E_DATA_ROOT ?? (await mkdtemp(path.join(os.tmpdir(), "forge-e2e-")));
+const app = await buildServer({ dataRoot });
+const close = async () => {
+    await app.close();
+    closeDatabase();
+};
+process.on("SIGINT", () => {
+    void close();
+});
+process.on("SIGTERM", () => {
+    void close();
+});
+await app.listen({ port, host });

package/dist/server/errors.js

@@ -0,0 +1,15 @@
+export class HttpError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(statusCode, code, message, details) {
+        super(message);
+        this.name = "HttpError";
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+    }
+}
+export function isHttpError(error) {
+    return error instanceof HttpError;
+}

package/dist/server/index.js

@@ -0,0 +1,16 @@
+import { buildServer } from "./app.js";
+import { closeDatabase } from "./db.js";
+const port = Number(process.env.PORT ?? 4317);
+const host = process.env.HOST ?? "0.0.0.0";
+const app = await buildServer();
+const close = async () => {
+    await app.close();
+    closeDatabase();
+};
+process.on("SIGINT", () => {
+    void close();
+});
+process.on("SIGTERM", () => {
+    void close();
+});
+await app.listen({ port, host });

package/dist/server/managers/base.js

@@ -0,0 +1,17 @@
+export class AbstractManager {
+}
+export class AbstractAuthAwareManager extends AbstractManager {
+    getNow(context) {
+        return context.now ?? new Date();
+    }
+}
+export class AbstractAuditedManager extends AbstractAuthAwareManager {
+}
+export class AbstractVersionedManager extends AbstractAuditedManager {
+}
+export class AbstractReadModelManager extends AbstractAuthAwareManager {
+}
+export class AbstractExternalManager extends AbstractManager {
+}
+export class AbstractWritableManager extends AbstractAuditedManager {
+}

package/dist/server/managers/contracts.js

@@ -0,0 +1,47 @@
+export class ManagerError extends Error {
+    code;
+    statusCode;
+    details;
+    constructor(message, code, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "ManagerError";
+    }
+}
+export class AuthRequiredError extends ManagerError {
+    constructor(message = "Authentication is required", details) {
+        super(message, "auth_required", 401, details);
+    }
+}
+export class AuthorizationDeniedError extends ManagerError {
+    constructor(message = "Authorization denied", details) {
+        super(message, "authorization_denied", 403, details);
+    }
+}
+export class InsufficientScopeError extends ManagerError {
+    constructor(message = "Insufficient scope", details) {
+        super(message, "insufficient_scope", 403, details);
+    }
+}
+export class ApprovalRequiredError extends ManagerError {
+    constructor(message = "Approval is required", details) {
+        super(message, "approval_required", 409, details);
+    }
+}
+export class ConcurrencyConflictError extends ManagerError {
+    constructor(message = "Concurrency conflict", details) {
+        super(message, "concurrency_conflict", 409, details);
+    }
+}
+export class ProviderUnavailableError extends ManagerError {
+    constructor(message = "Provider unavailable", details) {
+        super(message, "provider_unavailable", 503, details);
+    }
+}
+export class ValidationFailedError extends ManagerError {
+    constructor(message = "Validation failed", details) {
+        super(message, "validation_failed", 400, details);
+    }
+}

package/dist/server/managers/platform/api-gateway-manager.js

@@ -0,0 +1,11 @@
+import { AbstractExternalManager } from "../base.js";
+export class ApiGatewayManager extends AbstractExternalManager {
+    name = "ApiGatewayManager";
+    config = null;
+    configure(config) {
+        this.config = config;
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/dist/server/managers/platform/audit-manager.js

@@ -0,0 +1,15 @@
+import { AbstractAuditedManager } from "../base.js";
+import { recordEventLog } from "../../repositories/event-log.js";
+export class AuditManager extends AbstractAuditedManager {
+    name = "AuditManager";
+    record(eventKind, entityType, entityId, context, metadata = {}) {
+        recordEventLog({
+            eventKind,
+            entityType,
+            entityId,
+            actor: context.actor ?? null,
+            source: context.source,
+            metadata
+        });
+    }
+}

package/dist/server/managers/platform/authentication-manager.js

@@ -0,0 +1,56 @@
+import { AbstractManager } from "../base.js";
+function readSingleHeaderValue(value) {
+    if (Array.isArray(value)) {
+        return value[0] ?? null;
+    }
+    return typeof value === "string" ? value : null;
+}
+function normalizeSource(value) {
+    if (value === "ui" || value === "agent" || value === "openclaw" || value === "system") {
+        return value;
+    }
+    return null;
+}
+export class AuthenticationManager extends AbstractManager {
+    sessionManager;
+    tokenManager;
+    name = "AuthenticationManager";
+    constructor(sessionManager, tokenManager) {
+        super();
+        this.sessionManager = sessionManager;
+        this.tokenManager = tokenManager;
+    }
+    authenticate(headers) {
+        const sourceHeader = readSingleHeaderValue(headers["x-forge-source"]);
+        const actorHeader = readSingleHeaderValue(headers["x-forge-actor"]);
+        const bearer = this.parseBearerToken(headers);
+        const token = bearer ? this.tokenManager.verifyBearerToken(bearer) : null;
+        const session = this.sessionManager.readSessionFromHeaders(headers);
+        const sourceOverride = normalizeSource(sourceHeader);
+        const actor = token?.agentLabel ?? session?.actorLabel ?? actorHeader ?? null;
+        const source = token ? sourceOverride ?? "agent" : sourceOverride ?? (session ? "ui" : "ui");
+        return {
+            now: new Date(),
+            correlationId: null,
+            requestId: null,
+            origin: readSingleHeaderValue(headers.origin),
+            host: readSingleHeaderValue(headers.host),
+            ip: null,
+            actor,
+            source,
+            token,
+            session
+        };
+    }
+    parseBearerToken(headers) {
+        const raw = readSingleHeaderValue(headers.authorization);
+        if (!raw) {
+            return null;
+        }
+        const [scheme, token] = raw.trim().split(/\s+/, 2);
+        if (scheme?.toLowerCase() !== "bearer" || !token) {
+            return null;
+        }
+        return token;
+    }
+}

package/dist/server/managers/platform/authorization-manager.js

@@ -0,0 +1,56 @@
+import { AbstractManager } from "../base.js";
+import { AuthRequiredError, InsufficientScopeError } from "../contracts.js";
+export class AuthorizationManager extends AbstractManager {
+    name = "AuthorizationManager";
+    requireAuthenticatedOperator(context, detail) {
+        if (context.session) {
+            return;
+        }
+        throw new AuthRequiredError("An authenticated operator session is required.", detail);
+    }
+    requireAuthenticatedActor(context, detail) {
+        if (context.session || context.token) {
+            return;
+        }
+        throw new AuthRequiredError("Authentication is required for this operation.", detail);
+    }
+    requireTokenScope(context, scope, detail) {
+        if (context.session) {
+            return;
+        }
+        if (!context.token) {
+            throw new AuthRequiredError("A token or operator session is required.", {
+                requiredScope: scope,
+                ...(detail ?? {})
+            });
+        }
+        if (!context.token.scopes.includes(scope)) {
+            throw new InsufficientScopeError(`This operation requires the ${scope} scope.`, {
+                requiredScope: scope,
+                scopes: context.token.scopes,
+                ...(detail ?? {})
+            });
+        }
+    }
+    requireAnyTokenScope(context, scopes, detail) {
+        if (context.session) {
+            return;
+        }
+        if (!context.token) {
+            throw new AuthRequiredError("A token or operator session is required.", {
+                requiredScopes: scopes,
+                ...(detail ?? {})
+            });
+        }
+        if (!scopes.some((scope) => context.token?.scopes.includes(scope))) {
+            throw new InsufficientScopeError(`This operation requires one of: ${scopes.join(", ")}.`, {
+                requiredScopes: scopes,
+                scopes: context.token.scopes,
+                ...(detail ?? {})
+            });
+        }
+    }
+    canManageOperator(context) {
+        return Boolean(context.session);
+    }
+}

package/dist/server/managers/platform/background-job-manager.js

@@ -0,0 +1,10 @@
+import { AbstractManager } from "../base.js";
+export class BackgroundJobManager extends AbstractManager {
+    name = "BackgroundJobManager";
+    start() {
+        return;
+    }
+    stop() {
+        return;
+    }
+}

package/dist/server/managers/platform/configuration-manager.js

@@ -0,0 +1,33 @@
+import { AbstractManager } from "../base.js";
+export class ConfigurationManager extends AbstractManager {
+    env;
+    name = "ConfigurationManager";
+    constructor(env = process.env) {
+        super();
+        this.env = env;
+    }
+    readRuntimeConfig(overrides = {}) {
+        return {
+            host: this.env.HOST?.trim() || "0.0.0.0",
+            port: Number(this.env.PORT ?? 4317),
+            basePath: this.normalizeBasePath(this.env.FORGE_BASE_PATH ?? "/forge/"),
+            dataRoot: overrides.dataRoot ? overrides.dataRoot : this.env.FORGE_DATA_ROOT?.trim() || null,
+            sessionCookieName: this.env.FORGE_OPERATOR_SESSION_COOKIE?.trim() || "forge_operator_session",
+            sessionTtlSeconds: Math.max(3600, Number(this.env.FORGE_OPERATOR_SESSION_TTL_SECONDS ?? 60 * 60 * 24 * 7)),
+            allowedOrigins: [
+                /^https?:\/\/localhost(?::\d+)?$/i,
+                /^https?:\/\/127\.0\.0\.1(?::\d+)?$/i,
+                /^https?:\/\/\[::1\](?::\d+)?$/i,
+                /^https?:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)*\.ts\.net(?::\d+)?$/i,
+                /^https?:\/\/100\.(?:\d{1,3})\.(?:\d{1,3})\.(?:\d{1,3})(?::\d+)?$/i
+            ]
+        };
+    }
+    normalizeBasePath(value) {
+        if (!value || value === "/") {
+            return "/";
+        }
+        const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+        return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+    }
+}

package/dist/server/managers/platform/database-manager.js

@@ -0,0 +1,14 @@
+import { AbstractManager } from "../base.js";
+import { closeDatabase, configureDatabase, getDatabase } from "../../db.js";
+export class DatabaseManager extends AbstractManager {
+    name = "DatabaseManager";
+    configure(dataRoot) {
+        configureDatabase({ dataRoot: dataRoot ?? undefined });
+    }
+    getConnection() {
+        return getDatabase();
+    }
+    close() {
+        closeDatabase();
+    }
+}

package/dist/server/managers/platform/event-bus-manager.js

@@ -0,0 +1,7 @@
+import { AbstractManager } from "../base.js";
+export class EventBusManager extends AbstractManager {
+    name = "EventBusManager";
+    publish(_event) {
+        return;
+    }
+}

package/dist/server/managers/platform/external-service-manager.js

@@ -0,0 +1,11 @@
+import { AbstractManager } from "../base.js";
+export class ExternalServiceManager extends AbstractManager {
+    name = "ExternalServiceManager";
+    providers = new Map();
+    register(name, metadata) {
+        this.providers.set(name, metadata);
+    }
+    list() {
+        return [...this.providers.entries()].map(([name, metadata]) => ({ name, ...metadata }));
+    }
+}

package/dist/server/managers/platform/health-manager.js

@@ -0,0 +1,7 @@
+import { AbstractManager } from "../base.js";
+export class HealthManager extends AbstractManager {
+    name = "HealthManager";
+    summarize(input) {
+        return input;
+    }
+}

package/dist/server/managers/platform/migration-manager.js

@@ -0,0 +1,8 @@
+import { AbstractManager } from "../base.js";
+import { initializeDatabase } from "../../db.js";
+export class MigrationManager extends AbstractManager {
+    name = "MigrationManager";
+    async initialize() {
+        await initializeDatabase();
+    }
+}