forge-openclaw-plugin 0.2.24 → 0.2.25

package/dist/server/repositories/model-settings.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase } from "../db.js";
+import { aiModelConnectionSchema, upsertAiModelConnectionSchema } from "../types.js";
+import { deleteEncryptedSecret, readEncryptedSecret, storeEncryptedSecret } from "./calendar.js";
+import { upsertWikiLlmProfile } from "./wiki-memory.js";
+export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+export const DEFAULT_OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+export const FORGE_MANAGED_WIKI_PROFILE_ID = "wiki_llm_forge_managed";
+export const FORGE_DEFAULT_AGENT_ID = "agt_forge_default";
+function parseMetadata(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function defaultAuthMode(provider) {
+    return provider === "openai-codex" ? "oauth" : "api_key";
+}
+export function defaultBaseUrlForProvider(provider) {
+    if (provider === "openai-codex") {
+        return DEFAULT_OPENAI_CODEX_BASE_URL;
+    }
+    if (provider === "openai-compatible") {
+        return "http://127.0.0.1:11434/v1";
+    }
+    return DEFAULT_OPENAI_BASE_URL;
+}
+function buildConnectionAgentId(connectionId) {
+    return `agt_model_${connectionId.replace(/[^a-zA-Z0-9]+/g, "_")}`;
+}
+export function buildConnectionAgentIdentity(connection) {
+    const detail = connection.provider === "openai-codex"
+        ? "Chat agent backed by OpenAI Codex OAuth."
+        : connection.provider === "openai-compatible"
+            ? "Chat agent backed by a local or OpenAI-compatible endpoint."
+            : "Chat agent backed by the OpenAI API.";
+    return {
+        id: connection.agentId,
+        label: connection.agentLabel,
+        agentType: connection.provider,
+        trustLevel: "trusted",
+        autonomyMode: "approval_required",
+        approvalMode: "approval_by_default",
+        description: detail,
+        tokenCount: 0,
+        activeTokenCount: 0,
+        createdAt: connection.createdAt,
+        updatedAt: connection.updatedAt
+    };
+}
+function mapConnection(row) {
+    const hasStoredCredential = Boolean(row.secret_id) && Boolean(readEncryptedSecret(row.secret_id));
+    return aiModelConnectionSchema.parse({
+        id: row.id,
+        label: row.label,
+        provider: row.provider,
+        authMode: row.auth_mode,
+        baseUrl: row.base_url,
+        model: row.model,
+        accountLabel: row.account_label,
+        enabled: row.enabled === 1,
+        status: hasStoredCredential ? "connected" : "needs_attention",
+        hasStoredCredential,
+        usesOAuth: row.auth_mode === "oauth",
+        supportsCustomBaseUrl: row.provider !== "openai-codex",
+        agentId: buildConnectionAgentId(row.id),
+        agentLabel: `${row.label} agent`,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    });
+}
+export function listAiModelConnections() {
+    const rows = getDatabase()
+        .prepare(`SELECT id, label, provider, auth_mode, base_url, model, account_label, secret_id, enabled, metadata_json, created_at, updated_at
+       FROM ai_model_connections
+       ORDER BY created_at DESC`)
+        .all();
+    return rows.map(mapConnection);
+}
+export function getAiModelConnectionById(connectionId) {
+    const row = getDatabase()
+        .prepare(`SELECT id, label, provider, auth_mode, base_url, model, account_label, secret_id, enabled, metadata_json, created_at, updated_at
+       FROM ai_model_connections
+       WHERE id = ?`)
+        .get(connectionId);
+    return row ? mapConnection(row) : null;
+}
+export function readModelConnectionCredential(connectionId, secrets) {
+    const row = getDatabase()
+        .prepare(`SELECT secret_id
+       FROM ai_model_connections
+       WHERE id = ?`)
+        .get(connectionId);
+    if (!row?.secret_id) {
+        return null;
+    }
+    const cipherText = readEncryptedSecret(row.secret_id);
+    if (!cipherText) {
+        return null;
+    }
+    return secrets.openJson(cipherText);
+}
+export function upsertAiModelConnection(input, secrets, options = {}) {
+    const parsed = upsertAiModelConnectionSchema.parse(input);
+    const existing = parsed.id?.trim()
+        ? getDatabase()
+            .prepare(`SELECT id, label, provider, auth_mode, base_url, model, account_label, secret_id, enabled, metadata_json, created_at, updated_at
+           FROM ai_model_connections
+           WHERE id = ?`)
+            .get(parsed.id.trim())
+        : undefined;
+    const id = existing?.id ??
+        `mdl_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+    const now = new Date().toISOString();
+    const provider = parsed.provider;
+    const authMode = parsed.authMode ?? defaultAuthMode(provider);
+    const baseUrl = parsed.baseUrl?.trim() ||
+        existing?.base_url ||
+        defaultBaseUrlForProvider(provider);
+    let secretId = existing?.secret_id ?? null;
+    let accountLabel = existing?.account_label ?? null;
+    if (parsed.apiKey?.trim()) {
+        secretId =
+            secretId ?? `mdl_secret_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        storeEncryptedSecret(secretId, secrets.sealJson({
+            kind: "api_key",
+            provider,
+            apiKey: parsed.apiKey.trim()
+        }), `${parsed.label} AI connection`);
+    }
+    else if (options.oauthCredential) {
+        secretId =
+            secretId ?? `mdl_secret_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        accountLabel = options.oauthCredential.accountId;
+        storeEncryptedSecret(secretId, secrets.sealJson(options.oauthCredential), `${parsed.label} AI OAuth connection`);
+    }
+    getDatabase()
+        .prepare(`INSERT INTO ai_model_connections (
+        id, label, provider, auth_mode, base_url, model, account_label, secret_id, enabled, metadata_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        label = excluded.label,
+        provider = excluded.provider,
+        auth_mode = excluded.auth_mode,
+        base_url = excluded.base_url,
+        model = excluded.model,
+        account_label = excluded.account_label,
+        secret_id = excluded.secret_id,
+        enabled = excluded.enabled,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`)
+        .run(id, parsed.label, provider, authMode, baseUrl, parsed.model.trim(), accountLabel, secretId, parsed.enabled ? 1 : 0, JSON.stringify(parseMetadata(existing?.metadata_json ?? "{}")), existing?.created_at ?? now, now);
+    return getAiModelConnectionById(id);
+}
+export function deleteAiModelConnection(connectionId, secrets) {
+    const row = getDatabase()
+        .prepare(`SELECT id, secret_id
+       FROM ai_model_connections
+       WHERE id = ?`)
+        .get(connectionId);
+    if (!row) {
+        return null;
+    }
+    getDatabase()
+        .prepare(`DELETE FROM ai_model_connections WHERE id = ?`)
+        .run(connectionId);
+    if (row.secret_id) {
+        deleteEncryptedSecret(row.secret_id);
+    }
+    getDatabase()
+        .prepare(`UPDATE app_settings
+       SET forge_basic_chat_connection_id = CASE WHEN forge_basic_chat_connection_id = ? THEN '' ELSE forge_basic_chat_connection_id END,
+           forge_wiki_connection_id = CASE WHEN forge_wiki_connection_id = ? THEN '' ELSE forge_wiki_connection_id END,
+           updated_at = ?
+       WHERE id = 1`)
+        .run(connectionId, connectionId, new Date().toISOString());
+    syncForgeManagedWikiProfile(secrets);
+    return row.id;
+}
+export function syncForgeManagedWikiProfile(secrets) {
+    const settings = getDatabase()
+        .prepare(`SELECT forge_wiki_connection_id, forge_wiki_model
+       FROM app_settings
+       WHERE id = 1`)
+        .get();
+    const connectionId = settings?.forge_wiki_connection_id?.trim() ?? "";
+    const fallbackModel = settings?.forge_wiki_model?.trim() || "gpt-5.4-mini";
+    const connection = connectionId ? getAiModelConnectionById(connectionId) : null;
+    const row = connectionId
+        ? getDatabase()
+            .prepare(`SELECT secret_id
+           FROM ai_model_connections
+           WHERE id = ?`)
+            .get(connectionId)
+        : undefined;
+    upsertWikiLlmProfile({
+        id: FORGE_MANAGED_WIKI_PROFILE_ID,
+        label: "Forge wiki ingest",
+        provider: connection?.provider === "openai-compatible"
+            ? "openai-compatible"
+            : connection?.provider === "openai-codex"
+                ? "openai-codex"
+                : "openai-responses",
+        baseUrl: connection?.baseUrl ?? DEFAULT_OPENAI_BASE_URL,
+        model: connection?.model ?? fallbackModel,
+        secretId: row?.secret_id ?? null,
+        enabled: true,
+        metadata: {
+            managedBySettings: true,
+            connectionId: connection?.id ?? null
+        }
+    }, secrets);
+}

package/dist/server/repositories/notes.js

@@ -80,6 +80,22 @@ function noteMatchesTextTerm(note, term) {
     }
     return note.tags.some((tag) => tag.toLowerCase().includes(normalized));
 }
+function filterNotesByOwnerIds(notes, userIds) {
+    if (!userIds || userIds.length === 0) {
+        return notes;
+    }
+    const allowed = new Set(userIds);
+    return notes.filter((note) => note.userId !== null && allowed.has(note.userId));
+}
+export function resolveNoteObservedAt(note) {
+    const observedAt = typeof note.frontmatter.observedAt === "string"
+        ? note.frontmatter.observedAt.trim()
+        : "";
+    if (observedAt.length > 0 && !Number.isNaN(Date.parse(observedAt))) {
+        return new Date(observedAt).toISOString();
+    }
+    return note.createdAt;
+}
 function cleanupExpiredNotes() {
     const expiredRows = getDatabase()
         .prepare(`SELECT id
@@ -198,6 +214,16 @@ function listAllNoteRows() {
        ORDER BY created_at DESC`)
         .all();
 }
+function listActiveNotes() {
+    const rows = listAllNoteRows();
+    const linksByNoteId = new Map();
+    for (const link of listLinkRowsForNotes(rows.map((row) => row.id))) {
+        const current = linksByNoteId.get(link.note_id) ?? [];
+        current.push(link);
+        linksByNoteId.set(link.note_id, current);
+    }
+    return filterDeletedEntities("note", rows.map((row) => mapNote(row, linksByNoteId.get(row.id) ?? [])));
+}
 function findMatchingNoteIds(query) {
     const ftsQuery = buildFtsQuery(query);
     if (!ftsQuery) {
@@ -313,23 +339,17 @@ export function listNotes(query = {}) {
         ...(parsed.query ? [parsed.query] : []),
         ...parsed.textTerms
     ]);
-    const rows = listAllNoteRows();
-    const linksByNoteId = new Map();
-    for (const link of listLinkRowsForNotes(rows.map((row) => row.id))) {
-        const current = linksByNoteId.get(link.note_id) ?? [];
-        current.push(link);
-        linksByNoteId.set(link.note_id, current);
-    }
-    return filterDeletedEntities("note", rows
-        .filter((row) => parsed.kind ? row.kind === parsed.kind : true)
-        .filter((row) => parsed.spaceId ? row.space_id === parsed.spaceId : true)
-        .filter((row) => parsed.slug ? row.slug.toLowerCase() === parsed.slug.toLowerCase() : true)
-        .filter((row) => parsed.author
-        ? (row.author ?? "")
+    return filterNotesByOwnerIds(listActiveNotes()
+        .filter((note) => parsed.kind ? note.kind === parsed.kind : true)
+        .filter((note) => parsed.spaceId ? note.spaceId === parsed.spaceId : true)
+        .filter((note) => parsed.slug
+        ? note.slug.toLowerCase() === parsed.slug.toLowerCase()
+        : true)
+        .filter((note) => parsed.author
+        ? (note.author ?? "")
             .toLowerCase()
             .includes(parsed.author.toLowerCase())
         : true)
-        .map((row) => mapNote(row, linksByNoteId.get(row.id) ?? []))
         .filter((note) => {
         if (!matchingIds) {
             return true;
@@ -361,7 +381,29 @@ export function listNotes(query = {}) {
         }
         return true;
     })
-        .slice(0, parsed.limit ?? 100));
+        .slice(0, parsed.limit ?? 100), parsed.userIds);
+}
+export function listNotesByObservedAtRange({ from, to, userIds, limit = 400 }) {
+    cleanupExpiredNotes();
+    const fromMs = Date.parse(from);
+    const toMs = Date.parse(to);
+    if (Number.isNaN(fromMs) || Number.isNaN(toMs)) {
+        return [];
+    }
+    return filterNotesByOwnerIds(listActiveNotes(), userIds)
+        .map((note) => ({
+        note,
+        observedAt: resolveNoteObservedAt(note)
+    }))
+        .filter(({ observedAt }) => {
+        const observedAtMs = Date.parse(observedAt);
+        return (!Number.isNaN(observedAtMs) &&
+            observedAtMs >= fromMs &&
+            observedAtMs < toMs);
+    })
+        .sort((left, right) => left.observedAt.localeCompare(right.observedAt))
+        .slice(0, limit)
+        .map(({ note }) => note);
 }
 export function createNote(input, context) {
     cleanupExpiredNotes();

package/dist/server/repositories/preferences.js

@@ -444,6 +444,53 @@ function listStoredScores(contextId) {
        WHERE context_id = ?`)
         .all(contextId);
 }
+export function listPreferenceContexts() {
+    return getDatabase()
+        .prepare(`SELECT id, profile_id, name, description, share_mode, active, is_default, decay_days, created_at, updated_at
+       FROM preference_contexts
+       ORDER BY created_at ASC`)
+        .all().map(mapContext);
+}
+export function getPreferenceContextById(contextId) {
+    return readContext(contextId) ?? undefined;
+}
+export function listPreferenceItems() {
+    return getDatabase()
+        .prepare(`SELECT id, profile_id, label, description, tags_json, feature_weights_json, source_entity_type, source_entity_id, metadata_json, created_at, updated_at
+       FROM preference_items
+       ORDER BY created_at ASC`)
+        .all().map(mapItem);
+}
+export function getPreferenceItemById(itemId) {
+    return getItemById(itemId) ?? undefined;
+}
+export function listPreferenceCatalogs() {
+    return getDatabase()
+        .prepare(`SELECT id, profile_id, domain, slug, title, description, source, archived, created_at, updated_at
+       FROM preference_catalogs
+       WHERE archived = 0
+       ORDER BY created_at ASC`)
+        .all()
+        .filter((row) => row.archived === 0)
+        .map((row) => readCatalog(row.id))
+        .filter((catalog) => catalog !== null);
+}
+export function getPreferenceCatalogById(catalogId) {
+    return readCatalog(catalogId) ?? undefined;
+}
+export function listPreferenceCatalogItems() {
+    return getDatabase()
+        .prepare(`SELECT id, catalog_id, label, description, tags_json, feature_weights_json, position, archived, created_at, updated_at
+       FROM preference_catalog_items
+       WHERE archived = 0
+       ORDER BY catalog_id ASC, position ASC, created_at ASC`)
+        .all()
+        .filter((row) => row.archived === 0)
+        .map(mapCatalogItem);
+}
+export function getPreferenceCatalogItemById(catalogItemId) {
+    return readCatalogItem(catalogItemId) ?? undefined;
+}
 function listStoredDimensions(contextId) {
     return getDatabase()
         .prepare(`SELECT id, profile_id, context_id, dimension_id, leaning, confidence, movement, context_sensitivity, evidence_count, updated_at
@@ -1535,6 +1582,55 @@ export function updatePreferenceContext(contextId, patch) {
     }
     return updated;
 }
+export function deletePreferenceContext(contextId) {
+    const current = readContext(contextId);
+    if (!current) {
+        throw new HttpError(404, "preferences_context_not_found", `Preference context ${contextId} was not found.`);
+    }
+    const remainingContexts = listContexts(current.profileId).filter((entry) => entry.id !== contextId);
+    if (remainingContexts.length === 0) {
+        throw new HttpError(400, "preferences_context_last_remaining", "A preference profile must keep at least one context.");
+    }
+    const replacementDefault = remainingContexts.find((entry) => entry.isDefault) ?? remainingContexts[0];
+    const timestamp = nowIso();
+    runInTransaction(() => {
+        getDatabase()
+            .prepare(`DELETE FROM pairwise_judgments WHERE context_id = ?`)
+            .run(contextId);
+        getDatabase()
+            .prepare(`DELETE FROM absolute_signals WHERE context_id = ?`)
+            .run(contextId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_item_scores WHERE context_id = ?`)
+            .run(contextId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_dimension_summaries WHERE context_id = ?`)
+            .run(contextId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_snapshots WHERE context_id = ?`)
+            .run(contextId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_contexts WHERE id = ?`)
+            .run(contextId);
+        if (current.isDefault) {
+            getDatabase()
+                .prepare(`UPDATE preference_contexts
+           SET is_default = CASE WHEN id = ? THEN 1 ELSE 0 END, updated_at = ?
+           WHERE profile_id = ?`)
+                .run(replacementDefault.id, timestamp, current.profileId);
+            getDatabase()
+                .prepare(`UPDATE preference_profiles
+           SET default_context_id = ?, updated_at = ?
+           WHERE id = ?`)
+                .run(replacementDefault.id, timestamp, current.profileId);
+        }
+    });
+    const profile = readProfileById(current.profileId);
+    if (profile) {
+        recomputeContext(profile, replacementDefault);
+    }
+    return current;
+}
 export function mergePreferenceContexts(input) {
     const parsed = mergePreferenceContextsSchema.parse(input);
     const source = readContext(parsed.sourceContextId);
@@ -1661,6 +1757,34 @@ export function updatePreferenceItem(itemId, patch) {
     }
     return updated;
 }
+export function deletePreferenceItem(itemId) {
+    const current = getItemById(itemId);
+    if (!current) {
+        throw new HttpError(404, "preferences_item_not_found", `Preference item ${itemId} was not found.`);
+    }
+    runInTransaction(() => {
+        getDatabase()
+            .prepare(`DELETE FROM pairwise_judgments
+         WHERE left_item_id = ? OR right_item_id = ?`)
+            .run(itemId, itemId);
+        getDatabase()
+            .prepare(`DELETE FROM absolute_signals WHERE item_id = ?`)
+            .run(itemId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_item_scores WHERE item_id = ?`)
+            .run(itemId);
+        getDatabase()
+            .prepare(`DELETE FROM preference_items WHERE id = ?`)
+            .run(itemId);
+    });
+    const profile = readProfileById(current.profileId);
+    if (profile) {
+        for (const context of listContexts(profile.id).filter((entry) => entry.active)) {
+            recomputeContext(profile, context);
+        }
+    }
+    return current;
+}
 export function createPreferenceItemFromEntity(input) {
     const parsed = enqueueEntityPreferenceItemSchema.parse(input);
     const profile = ensureProfile(parsed.userId, parsed.domain);