dsh-reference-anything 0.3.1 → 0.3.2

package/lib/sources/web-chat/index.js

@@ -7,8 +7,10 @@ import { OpenCliError, OpenCliRunner, discoverOpenCli, installOpenCli as install
 import { PACKAGE_NAME, PackageUpdateManager } from "../../update.js";
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { isDeepStrictEqual } from 'node:util';
 import { ReferenceAnythingError } from "../../errors.js";
 import { parseProviderQuery } from "../../search.js";
+import { validateDownloadDirectory } from "../../download-directory.js";
 export { parseProviderQuery };
 export const name = 'reference-web-chat';
 export const inject = ['references', 'storageDomain'];
@@ -25,10 +27,14 @@ export default class WebChatHistoryService extends Service {
     static inject = inject;
     static Config = Config;
     id = 'web-chat';
+    /** Mirrored browser chats are outside the task's workspace: read only what the user named. */
+    requiresGrant = true;
     storeValue;
     syncValue;
     autoSyncInterval;
     autoSyncCatchUp;
+    settingsUpdateQueue = Promise.resolve();
+    validateDownloadDirectoryValue = validateDownloadDirectory;
     packageUpdates = new PackageUpdateManager({
         afterInstall: async (profileDir, _version, signal) => {
             await this.installAdapterFrom(pathToFileURL(join(profileDir, 'node_modules', PACKAGE_NAME, 'opencli-plugin')).href, signal);
@@ -50,6 +56,9 @@ export default class WebChatHistoryService extends Service {
             await this.store.setSettings(this.store.settings);
             await this.store.clearMirrorContent();
         }
+        if (this.store.settings.syncHistoryDays !== null) {
+            await this.store.removeOlderThan(this.store.settings.syncHistoryDays);
+        }
         this.syncValue = new ConversationSyncManager(this.storeValue, () => new OpenCliRunner({
             executable: this.store.settings.opencliPath, profile: this.store.settings.profile,
             timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes,
@@ -179,11 +188,6 @@ export default class WebChatHistoryService extends Service {
             throw new ReferenceAnythingError('cannot clear provider data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
         return this.store.removeProvider(provider);
     }
-    async removeOlderThan(days) {
-        if (this.sync.isRunning())
-            throw new ReferenceAnythingError('cannot clear old data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
-        return this.store.removeOlderThan(days);
-    }
     async removeRemoteMissing() {
         if (this.sync.isRunning())
             throw new ReferenceAnythingError('cannot clear remote-missing data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
@@ -215,12 +219,36 @@ export default class WebChatHistoryService extends Service {
         }
         return discovery;
     }
-    async updateSettings(value) {
-        const settings = settingsRecordSchema.parse(value);
-        const enteringMetadataOnly = settings.historyMode === 'metadata-only' && this.store.settings.historyMode !== 'metadata-only';
+    updateSettings(value) {
+        const submittedAgainst = this.store.settings;
+        const pending = (this.settingsUpdateQueue ?? Promise.resolve()).then(() => this.applySettings(value, submittedAgainst));
+        // Keep the serialization tail fulfilled so one rejected mutation does not
+        // prevent a later, valid settings request from running.
+        this.settingsUpdateQueue = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
+    async applySettings(value, submittedAgainst) {
+        const submitted = settingsRecordSchema.parse(value);
+        const directoryChanged = !isDeepStrictEqual(submitted.cloudDriveDownloadDirectory, submittedAgainst.cloudDriveDownloadDirectory);
+        let validatedDirectory = submitted.cloudDriveDownloadDirectory;
+        if (directoryChanged) {
+            const validateDirectory = this.validateDownloadDirectoryValue ?? validateDownloadDirectory;
+            validatedDirectory = await validateDirectory(validatedDirectory);
+        }
+        // Validation can be slow (especially for a network drive). Merge against a
+        // fresh value so direct writers such as installOpenCli are not overwritten
+        // by the snapshot captured before that await.
+        const current = this.store.settings;
+        let settings = mergeSettingsUpdate(submittedAgainst, current, submitted);
+        if (directoryChanged)
+            settings = { ...settings, cloudDriveDownloadDirectory: validatedDirectory };
+        const enteringMetadataOnly = settings.historyMode === 'metadata-only' && current.historyMode !== 'metadata-only';
+        const historyRangeChanged = settings.syncHistoryDays !== current.syncHistoryDays;
         await this.store.setSettings(settings);
         if (enteringMetadataOnly)
             await this.store.clearMirrorContent();
+        if (historyRangeChanged && settings.syncHistoryDays !== null)
+            await this.store.removeOlderThan(settings.syncHistoryDays);
         this.armAutoSync();
         return settings;
     }
@@ -330,6 +358,17 @@ export default class WebChatHistoryService extends Service {
         }
     }
 }
+/** Apply only fields changed by this full-record request since its submission snapshot. */
+function mergeSettingsUpdate(submittedAgainst, current, submitted) {
+    const merged = { ...current };
+    const keys = new Set([...Object.keys(submittedAgainst), ...Object.keys(submitted)]);
+    for (const key of keys) {
+        if (!isDeepStrictEqual(submitted[key], submittedAgainst[key])) {
+            Object.assign(merged, { [key]: submitted[key] });
+        }
+    }
+    return settingsRecordSchema.parse(merged);
+}
 /** Spread a period by ±10% so providers and instances do not all fire together. */
 function jitter(period) {
     return Math.round(period * (0.9 + Math.random() * 0.2));

package/lib/store/spec.d.ts

@@ -171,6 +171,7 @@ export declare const referenceAnythingDomainSpec: {
         schema: z.ZodObject<{
             opencliPath: z.ZodString;
             profile: z.ZodString;
+            cloudDriveDownloadDirectory: z.ZodDefault<z.ZodString>;
             detailConcurrency: z.ZodNumber;
             autoSync: z.ZodDefault<z.ZodBoolean>;
             syncOnStartup: z.ZodDefault<z.ZodBoolean>;
@@ -179,6 +180,7 @@ export declare const referenceAnythingDomainSpec: {
                 "metadata-only": "metadata-only";
                 "offline-mirror": "offline-mirror";
             }>>;
+            syncHistoryDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
             enabledProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
                 chatgpt: "chatgpt";
                 claude: "claude";
@@ -187,6 +189,39 @@ export declare const referenceAnythingDomainSpec: {
                 grok: "grok";
                 kimi: "kimi";
             }>>>;
+            enabledAgents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                kimi: "kimi";
+                "claude-code": "claude-code";
+                codex: "codex";
+                cursor: "cursor";
+                qoder: "qoder";
+                reasonix: "reasonix";
+                openclaw: "openclaw";
+                grokbuild: "grokbuild";
+                hermes: "hermes";
+                "gemini-cli": "gemini-cli";
+                pi: "pi";
+                opencode: "opencode";
+                mimocode: "mimocode";
+                zcode: "zcode";
+            }>>>;
+            agentDirectories: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                kimi: "kimi";
+                "claude-code": "claude-code";
+                codex: "codex";
+                cursor: "cursor";
+                qoder: "qoder";
+                reasonix: "reasonix";
+                openclaw: "openclaw";
+                grokbuild: "grokbuild";
+                hermes: "hermes";
+                "gemini-cli": "gemini-cli";
+                pi: "pi";
+                opencode: "opencode";
+                mimocode: "mimocode";
+                zcode: "zcode";
+            }> & z.core.$partial, z.ZodString>>;
+            enabledDriveMounts: z.ZodOptional<z.ZodArray<z.ZodString>>;
             maxReadTurns: z.ZodDefault<z.ZodNumber>;
             inputRenderMode: z.ZodDefault<z.ZodEnum<{
                 pill: "pill";
@@ -221,23 +256,38 @@ export declare const referenceAnythingDomainSpec: {
                     limit: z.ZodNumber;
                     maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
+                agents: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
                 conversations: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
                     maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
+                drives: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
         initial: {
             opencliPath: string;
             profile: string;
+            cloudDriveDownloadDirectory: string;
             detailConcurrency: number;
             autoSync: boolean;
             syncOnStartup: boolean;
             autoSyncMinutes: number;
             historyMode: "metadata-only";
+            syncHistoryDays: null;
             enabledProviders: ("chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi")[];
+            enabledAgents: ("kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode")[];
             maxReadTurns: number;
             inputRenderMode: "pill";
         };

package/lib/store/spec.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
-import { providerSchema, settingsRecordSchema } from "../wire.js";
+import { ALL_LOCAL_AGENTS, providerSchema, settingsRecordSchema } from "../wire.js";
 export { providerSchema, settingsRecordSchema };
 export const storedAttachmentSchema = z.object({
     attachmentId: z.string(),
@@ -82,7 +82,7 @@ export const referenceAnythingDomainSpec = defineDomain({
     version: 1,
     global: {
         schema: settingsRecordSchema,
-        initial: { opencliPath: 'opencli', profile: '', detailConcurrency: 8, autoSync: false, syncOnStartup: false, autoSyncMinutes: 60, historyMode: 'metadata-only', enabledProviders: [...providerSchema.options], maxReadTurns: 10, inputRenderMode: 'pill' },
+        initial: { opencliPath: 'opencli', profile: '', cloudDriveDownloadDirectory: '', detailConcurrency: 8, autoSync: false, syncOnStartup: false, autoSyncMinutes: 60, historyMode: 'metadata-only', syncHistoryDays: null, enabledProviders: [...providerSchema.options], enabledAgents: [...ALL_LOCAL_AGENTS], maxReadTurns: 10, inputRenderMode: 'pill' },
     },
     tables: {
         conversations: domainTable(conversationRecordSchema),

package/lib/sync/index.d.ts

@@ -79,6 +79,7 @@ export declare class ConversationSyncManager {
      * @returns an ISO instant the adapter may page back to, exclusive of slack.
      */
     private listingSince;
+    private historySince;
     private progressWriter;
     /** Newest durable account scope for a provider, used only as an incremental listing hint. */
     private latestAccountScope;

package/lib/sync/index.js

@@ -109,6 +109,9 @@ export class ConversationSyncManager {
         const failures = new Map();
         let succeeded = 0;
         try {
+            const historyDays = this.store.settings.syncHistoryDays;
+            if (historyDays !== null)
+                await this.store.removeOlderThan(historyDays);
             for (const provider of job.providers) {
                 if (job.controller.signal.aborted)
                     break;
@@ -128,6 +131,9 @@ export class ConversationSyncManager {
                     this.logger?.warn(`reference sync: ${provider} failed: ${describe(error)}`);
                 }
             }
+            const currentHistoryDays = this.store.settings.syncHistoryDays;
+            if (currentHistoryDays !== null)
+                await this.store.removeOlderThan(currentHistoryDays);
             job.status = job.controller.signal.aborted ? 'cancelled'
                 : failures.size === 0 ? 'complete'
                     : succeeded === 0 ? 'failed' : 'partial';
@@ -175,7 +181,7 @@ export class ConversationSyncManager {
         let accountScope = '';
         let progress;
         try {
-            const sinceFor = (scope) => mode === 'incremental' ? this.listingSince(provider, scope) : '';
+            const sinceFor = (scope) => this.listingSince(provider, scope, mode);
             let rows;
             let since = '';
             if (typeof runner.syncIndex === 'function') {
@@ -202,7 +208,13 @@ export class ConversationSyncManager {
             // changed rows when a trustworthy watermark exists, then fetch detail
             // only for rows whose provider timestamp changed. Full always enumerates
             // and re-fetches everything, replacing each current local revision.
-            const seen = new Set(rows.map(row => row.id));
+            const listedRows = rows;
+            const historySince = this.historySince();
+            if (historySince) {
+                const cutoff = Date.parse(historySince);
+                rows = rows.filter(row => { const updatedAt = Date.parse(row.updatedAt); return Number.isNaN(updatedAt) || updatedAt >= cutoff; });
+            }
+            const seen = new Set(listedRows.map(row => row.id));
             job.total += rows.length;
             const providerProgress = this.providerProgress(job, provider);
             providerProgress.phase = 'syncing';
@@ -251,7 +263,7 @@ export class ConversationSyncManager {
             if (enumerated)
                 await this.store.markRemoteMissing(provider, accountScope, seen);
             await progress.save('idle', {
-                cursor: rows.at(-1)?.cursor ?? '',
+                cursor: listedRows.at(-1)?.cursor ?? '',
                 complete: enumerated,
                 ...(failures.length > 0 ? { error: `${String(failures.length)} conversations failed; ${summarize(failures)}` } : {}),
             });
@@ -300,15 +312,23 @@ export class ConversationSyncManager {
      * Watermark for an incremental listing, or `''` to demand a full one.
      * @returns an ISO instant the adapter may page back to, exclusive of slack.
      */
-    listingSince(provider, accountScope) {
+    listingSince(provider, accountScope, mode) {
+        const historySince = this.historySince();
+        if (mode === 'full')
+            return historySince;
         const state = this.store.syncStates.get(`${provider}:${accountScope}`);
         const lastComplete = Date.parse(state?.lastCompleteScanAt ?? '');
         const lastSync = Date.parse(state?.lastSyncAt ?? '');
         if (Number.isNaN(lastComplete) || Number.isNaN(lastSync))
-            return '';
+            return historySince;
         if (Date.now() - lastComplete >= FULL_SCAN_INTERVAL_MS)
-            return '';
-        return new Date(lastSync - LISTING_OVERLAP_MS).toISOString();
+            return historySince;
+        const incrementalSince = new Date(lastSync - LISTING_OVERLAP_MS).toISOString();
+        return historySince > incrementalSince ? historySince : incrementalSince;
+    }
+    historySince() {
+        const days = this.store.settings.syncHistoryDays;
+        return days === null ? '' : new Date(Date.now() - days * 24 * 60 * 60_000).toISOString();
     }
     progressWriter(provider, accountScope, job, total) {
         let completed = 0;
@@ -413,7 +433,7 @@ function isRetryable(error) {
 function isFatal(error) {
     return error instanceof OpenCliError && (error.code === 'OPENCLI_CONFIGURATION'
         || error.code === 'PROVIDER_NOT_LOGGED_IN' || error.code === 'PROVIDER_ACCOUNT_MISMATCH'
-        || error.code === 'EXTENSION_NOT_CONNECTED');
+        || error.code === 'PROVIDER_RATE_LIMIT' || error.code === 'EXTENSION_NOT_CONNECTED');
 }
 function summarize(failures) {
     const head = failures.slice(0, 3).join('; ');

package/lib/tool.d.ts

@@ -23,6 +23,10 @@ export declare const DEFAULT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_READ_TURNS = 10;
 /** Ceiling on the model-supplied turn limit when none is configured. */
 export declare const DEFAULT_MAX_READ_TURNS = 100;
+/** Hard attachment cap shared by drive and Web materialization. */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/** Successful materializations remain usable for one hour. */
+export declare const ATTACHMENT_LIFETIME_MS: number;
 /** Deployment settings for the model-facing tools. */
 export interface Config {
     /** Items `reference_list` may return; also the cap the model cannot raise. */
@@ -59,4 +63,5 @@ export declare function parseWindow(args: {
     limit?: number;
     before?: number;
     cursor?: string;
+    detail?: 'summary' | 'full';
 }, fallback: number, ceiling: number): ReferenceWindow;