sfbench 0.1.0

package/dist/server/store.js

@@ -0,0 +1,201 @@
+// Settings and query history, stored under ~/.sfbench. See docs/design.md ("データの保存").
+import { join } from 'node:path';
+import { AI_PROVIDERS, isValidTimeout, squashSoql, REST_METHODS } from "../shared/api.js";
+import { randomUUID } from 'node:crypto';
+import { readJson, writeFileAtomic } from "./fsutil.js";
+export const DEFAULT_SETTINGS = { omitNamespace: true, requestTimeoutSeconds: 120 };
+function isProvider(value) {
+    return AI_PROVIDERS.includes(value);
+}
+function loadAi(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const v = value;
+    if (!isProvider(v.provider))
+        return undefined;
+    const ai = { provider: v.provider, model: typeof v.model === 'string' ? v.model : '' };
+    // A key is kept only with the provider it was entered for (Off keeps it for when that provider is chosen again).
+    const keyProvider = isProvider(v.keyProvider) && v.keyProvider !== 'off' ? v.keyProvider : undefined;
+    if (typeof v.apiKey === 'string' && v.apiKey && keyProvider && (v.provider === 'off' || v.provider === keyProvider)) {
+        ai.apiKey = v.apiKey;
+        ai.keyProvider = keyProvider;
+    }
+    return ai;
+}
+export function loadSettings(file) {
+    const stored = readJson(file);
+    const s = stored && typeof stored === 'object' ? stored : {};
+    const settings = {
+        omitNamespace: typeof s.omitNamespace === 'boolean' ? s.omitNamespace : DEFAULT_SETTINGS.omitNamespace,
+        requestTimeoutSeconds: isValidTimeout(s.requestTimeoutSeconds)
+            ? s.requestTimeoutSeconds
+            : DEFAULT_SETTINGS.requestTimeoutSeconds,
+    };
+    const ai = loadAi(s.ai);
+    if (ai)
+        settings.ai = ai;
+    return settings;
+}
+/** Written with mode 0600 (writeFileAtomic): the file holds the AI's API key. */
+export function saveSettings(file, settings) {
+    writeFileAtomic(file, JSON.stringify(settings, null, 2));
+}
+/** What the web UI gets: the AI settings without the key. */
+export function settingsView(settings) {
+    const { ai, ...rest } = settings;
+    if (!ai)
+        return rest;
+    const view = { provider: ai.provider, model: ai.model, hasApiKey: Boolean(ai.apiKey) };
+    if (ai.apiKey && ai.keyProvider)
+        view.keyProvider = ai.keyProvider;
+    return { ...rest, ai: view };
+}
+export class AiSettingsError extends Error {
+}
+/**
+ * Merges the AI settings sent by the web UI into the saved ones
+ * (docs/ai.md "API"). Leaving out apiKey keeps the saved key, null removes
+ * it, and choosing another provider (other than Off) drops it, so that a key
+ * never goes to a provider it was not entered for.
+ */
+export function mergeAiSettings(saved, input) {
+    if (!input || typeof input !== 'object')
+        throw new AiSettingsError('ai must be an object.');
+    const v = input;
+    if (!isProvider(v.provider))
+        throw new AiSettingsError('ai.provider must be off, anthropic or openai.');
+    if (v.model !== undefined && typeof v.model !== 'string')
+        throw new AiSettingsError('ai.model must be a string.');
+    if (v.apiKey !== undefined && v.apiKey !== null && typeof v.apiKey !== 'string') {
+        throw new AiSettingsError('ai.apiKey must be a string or null.');
+    }
+    const provider = v.provider;
+    const model = typeof v.model === 'string' ? v.model.trim() : (saved?.model ?? '');
+    if (provider !== 'off' && !model)
+        throw new AiSettingsError('Enter the model ID.');
+    let apiKey = saved?.apiKey;
+    let keyProvider = saved?.keyProvider;
+    if (provider !== 'off' && keyProvider !== provider) {
+        apiKey = undefined;
+        keyProvider = undefined;
+    }
+    if (v.apiKey === null) {
+        apiKey = undefined;
+        keyProvider = undefined;
+    }
+    else if (typeof v.apiKey === 'string' && v.apiKey.trim() && provider !== 'off') {
+        apiKey = v.apiKey.trim();
+        keyProvider = provider;
+    }
+    const merged = { provider, model };
+    if (apiKey && keyProvider) {
+        merged.apiKey = apiKey;
+        merged.keyProvider = keyProvider;
+    }
+    return merged;
+}
+/**
+ * Settings kept in memory: they are read on every Salesforce request, so the
+ * file is read once at startup and written on each change.
+ */
+export class SettingsStore {
+    file;
+    current;
+    constructor(file) {
+        this.file = file;
+        this.current = loadSettings(file);
+    }
+    get() {
+        return this.current;
+    }
+    set(settings) {
+        saveSettings(this.file, settings);
+        this.current = settings;
+        return settings;
+    }
+}
+export const MAX_HISTORY = 100;
+/** File name for an org's history: characters other than letters, digits, @ . - _ become _. */
+export function historyFile(dir, username) {
+    return join(dir, `${username.replace(/[^A-Za-z0-9@._-]/g, '_')}.json`);
+}
+export function loadHistory(dir, username) {
+    const stored = readJson(historyFile(dir, username));
+    return Array.isArray(stored) ? stored : [];
+}
+/**
+ * Adds a successful query. The same query moves to the top instead of being
+ * added twice, keeping the request to the AI that wrote it if this run has none.
+ */
+export function addHistory(dir, username, entry) {
+    const sameQuery = (e) => squashSoql(e.soql) === squashSoql(entry.soql) && e.tooling === entry.tooling && e.queryAll === entry.queryAll;
+    const previous = loadHistory(dir, username);
+    const prompt = entry.prompt ?? previous.find(sameQuery)?.prompt;
+    const added = prompt ? { ...entry, prompt } : entry;
+    const entries = [added, ...previous.filter((e) => !sameQuery(e))].slice(0, MAX_HISTORY);
+    writeFileAtomic(historyFile(dir, username), JSON.stringify(entries, null, 2));
+    return entries;
+}
+/** At most this much of a request body is kept in the REST history (docs/rest.md "残すもの"). */
+export const MAX_REST_HISTORY_BODY = 32 * 1024;
+function isExecRecord(e) {
+    if (!e || typeof e !== 'object')
+        return false;
+    const r = e;
+    const outcome = r.outcome;
+    return typeof r.id === 'string' && typeof r.sentAt === 'string' && !!outcome && ['pending', 'done', 'unknown'].includes(outcome.state);
+}
+function loadExec(file, valid) {
+    const stored = readJson(file);
+    // A record of another shape (a damaged or hand-edited file) is dropped.
+    return Array.isArray(stored) ? stored.filter((e) => isExecRecord(e) && valid(e)) : [];
+}
+/** Newest first. A request still pending from a server that has stopped (another bootId) shows as unknown, not as waiting for ever. */
+function loadExecHistory(file, bootId, valid) {
+    return loadExec(file, valid).map(({ bootId: entryBoot, ...entry }) => entry.outcome.state === 'pending' && entryBoot !== bootId ? { ...entry, outcome: { state: 'unknown', reason: 'stopped' } } : entry);
+}
+/** Records a request as pending; the same request twice is two records. Returns its id. */
+function addExecPending(file, fields, bootId, valid) {
+    const id = randomUUID();
+    const entry = { id, ...fields, sentAt: new Date().toISOString(), outcome: { state: 'pending' }, bootId };
+    const entries = [entry, ...loadExec(file, valid)].slice(0, MAX_HISTORY);
+    // Not indented: the file is rewritten twice for each request.
+    writeFileAtomic(file, JSON.stringify(entries));
+    return id;
+}
+/** Writes how a request ended; `undefined` removes the record (never processed). A missing record is not added again. */
+function finishExec(file, id, outcome, valid) {
+    const entries = loadExec(file, valid);
+    if (!entries.some((e) => e.id === id))
+        return;
+    const next = outcome ? entries.map((e) => (e.id === id ? { ...e, outcome } : e)) : entries.filter((e) => e.id !== id);
+    writeFileAtomic(file, JSON.stringify(next));
+}
+const isRestRecord = (r) => typeof r.method === 'string' && REST_METHODS.includes(r.method) && typeof r.path === 'string';
+export function loadRestHistory(dir, username, bootId) {
+    return loadExecHistory(historyFile(dir, username), bootId, isRestRecord);
+}
+/** Records a REST request just before it is sent, as pending. Returns its id. */
+export function addRestPending(dir, username, request, bootId) {
+    const keepBody = request.body !== undefined && Buffer.byteLength(request.body) <= MAX_REST_HISTORY_BODY;
+    return addExecPending(historyFile(dir, username), {
+        method: request.method,
+        path: request.path,
+        ...(Object.keys(request.headers).length ? { headers: request.headers } : {}),
+        ...(keepBody ? { body: request.body } : request.body !== undefined ? { bodyOmitted: true } : {}),
+    }, bootId, isRestRecord);
+}
+export function finishRest(dir, username, id, outcome) {
+    finishExec(historyFile(dir, username), id, outcome, isRestRecord);
+}
+const isApexRecord = (r) => typeof r.code === 'string';
+export function loadApexHistory(dir, username, bootId) {
+    return loadExecHistory(historyFile(dir, username), bootId, isApexRecord);
+}
+/** Records Apex just before it runs, as pending, with the whole code (at most MAX_APEX_CODE). Returns its id. */
+export function addApexPending(dir, username, code, bootId) {
+    return addExecPending(historyFile(dir, username), { code }, bootId, isApexRecord);
+}
+export function finishApex(dir, username, id, outcome) {
+    finishExec(historyFile(dir, username), id, outcome, isApexRecord);
+}

package/dist/server/version.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { packageRoot } from "./paths.js";
+let cached;
+export function packageVersion() {
+    cached ??= JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8')).version;
+    return cached;
+}

package/dist/shared/api.js

@@ -0,0 +1,31 @@
+// Types of the local server's HTTP API, shared by the server and the web UI.
+// See docs/design.md ("API").
+export const MIN_TIMEOUT_SECONDS = 10;
+export const MAX_TIMEOUT_SECONDS = 600;
+export function isValidTimeout(value) {
+    return Number.isInteger(value) && value >= MIN_TIMEOUT_SECONDS && value <= MAX_TIMEOUT_SECONDS;
+}
+/** The AI providers sfbench can call: Anthropic or OpenAI, or none (docs/ai.md). */
+export const AI_PROVIDERS = ['off', 'anthropic', 'openai'];
+/** The longest anonymous Apex sfbench takes: about Salesforce's limit (docs/apex.md "前提にする事実"). */
+export const MAX_APEX_CODE = 32_000;
+/** At most this many records go in one save or delete: one sObject Collections call (docs/edit.md "サーバー"). */
+export const MAX_RECORDS_PER_CALL = 200;
+/** The methods the REST API screen sends (docs/rest.md "要求"). */
+export const REST_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
+/** Whether a request with this method carries a body: the server checks it, the screen disables the body for the others. */
+export function methodTakesBody(method) {
+    return method === 'POST' || method === 'PATCH' || method === 'PUT';
+}
+/** Whether a path is under /services/, the only paths sfbench sends to Salesforce (the origin is checked by the server). */
+export function isServicesPath(path) {
+    return path.startsWith('/services/');
+}
+/**
+ * A query with its spaces and line breaks squashed, so that Format does not
+ * make another query: the history (addHistory) and the request to the AI
+ * behind a query (src/web/ai/promptMark.ts) compare queries this way.
+ */
+export function squashSoql(soql) {
+    return soql.trim().replace(/\s+/g, ' ');
+}

package/dist/shared/namespace.js

@@ -0,0 +1,28 @@
+// The org's namespace prefix: omitted when composing SOQL, ignored when matching
+// names (docs/web.md "SOQL と項目の選択の同期").
+function stripOne(name, ns) {
+    const prefix = `${ns}__`;
+    return name.toLowerCase().startsWith(prefix.toLowerCase()) ? name.slice(prefix.length) : name;
+}
+/** Removes the namespace from each dot-separated part. */
+export function stripNamespace(name, ns) {
+    if (!ns)
+        return name;
+    return name
+        .split('.')
+        .map((part) => stripOne(part, ns))
+        .join('.');
+}
+/** A key for comparing names: namespace removed, case ignored. */
+export function nameKey(name, ns) {
+    return stripNamespace(name, ns).toLowerCase();
+}
+/** The name to write into SOQL, following the "omit the namespace" setting. */
+export function soqlName(name, ns, omitNamespace) {
+    return omitNamespace ? stripNamespace(name, ns) : name;
+}
+/** The item named in SOQL (matching case and namespace loosely), such as an object in the describeGlobal list. */
+export function findByName(items, name, ns) {
+    const key = nameKey(name, ns);
+    return items.find((item) => nameKey(item.name, ns) === key);
+}