dsh-reference-anything 0.3.0 → 0.3.2

package/lib/contract.d.ts

@@ -1,5 +1,49 @@
 import { z } from 'zod';
 import type { InvocationDescriptor } from '@deepseek-ai/dsh-typert-protocol';
+/**
+ * One local-agent transcript as the `@` menu sees it.
+ *
+ * `id` is the source-scoped `kind:relPath`, not a `dsh-ref:` URI — the client
+ * wraps it, the way it does for web chats, so the `'local-agent'` source string
+ * stays hardcoded in exactly one place. Deliberately carries no `origin`: the
+ * absolute path adds nothing a menu row can use and everything a screen-share
+ * leaks.
+ */
+export declare const agentCandidateSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    label: z.ZodString;
+    provider: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const agentStatsSchema: z.ZodReadonly<z.ZodObject<{
+    agent: 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";
+    }>;
+    conversations: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const driveCandidateSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    provider: z.ZodString;
+    origin: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+    searchIncomplete: z.ZodOptional<z.ZodBoolean>;
+    isDirectory: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
 export declare const searchInputSchema: z.ZodReadonly<z.ZodObject<{
     query: z.ZodString;
     provider: z.ZodOptional<z.ZodEnum<{
@@ -92,25 +136,14 @@ export declare const packageUpdateStatusSchema: z.ZodReadonly<z.ZodObject<{
     latestVersion: z.ZodString;
     updateAvailable: z.ZodBoolean;
     checkedAt: z.ZodNumber;
+    releaseNotes: z.ZodOptional<z.ZodString>;
+    releaseUrl: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export declare const packageUpdateResultSchema: z.ZodReadonly<z.ZodObject<{
     version: z.ZodString;
     restartRequired: z.ZodBoolean;
 }, z.core.$strip>>;
-export declare const referenceUiModeInputSchema: z.ZodReadonly<z.ZodObject<{
-    mode: z.ZodEnum<{
-        plugin: "plugin";
-        official: "official";
-    }>;
-}, z.core.$strip>>;
-export declare const referenceUiSwitchResultSchema: z.ZodReadonly<z.ZodObject<{
-    mode: z.ZodEnum<{
-        plugin: "plugin";
-        official: "official";
-    }>;
-    restartRequired: z.ZodLiteral<false>;
-}, z.core.$strip>>;
 export declare const providerStatsSchema: z.ZodReadonly<z.ZodObject<{
     provider: z.ZodEnum<{
         chatgpt: "chatgpt";
@@ -287,9 +320,6 @@ export declare const clearProviderInputSchema: z.ZodReadonly<z.ZodObject<{
         kimi: "kimi";
     }>;
 }, z.core.$strip>>;
-export declare const clearOlderInputSchema: z.ZodReadonly<z.ZodObject<{
-    days: z.ZodNumber;
-}, z.core.$strip>>;
 export declare const providerSyncStateSchema: z.ZodReadonly<z.ZodObject<{
     provider: z.ZodEnum<{
         chatgpt: "chatgpt";
@@ -309,4 +339,113 @@ export declare const providerSyncStateSchema: z.ZodReadonly<z.ZodObject<{
     lastCompleteScanAt: z.ZodString;
     error: z.ZodString;
 }, z.core.$strip>>;
+export declare const openListStatusSchema: z.ZodReadonly<z.ZodObject<{
+    state: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        install: "install";
+        downloading: "downloading";
+        upgrade: "upgrade";
+    }>;
+    installed: z.ZodBoolean;
+    mode: z.ZodOptional<z.ZodEnum<{
+        managed: "managed";
+        external: "external";
+    }>>;
+    version: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    supportsRollback: z.ZodBoolean;
+    upgradeAvailable: z.ZodBoolean;
+    newerVersion: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare const openListDriverFieldSchema: z.ZodReadonly<z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        password: "password";
+        select: "select";
+    }>;
+    secret: z.ZodBoolean;
+    required: z.ZodBoolean;
+    hasDefault: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>>;
+}, z.core.$strict>>;
+export declare const openListDriverSchema: z.ZodReadonly<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    quickAuth: z.ZodBoolean;
+    fields: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            password: "password";
+            select: "select";
+        }>;
+        secret: z.ZodBoolean;
+        required: z.ZodBoolean;
+        hasDefault: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const openListMountSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    driver: z.ZodString;
+    enabled: z.ZodBoolean;
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        ready: "ready";
+        disabled: "disabled";
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+    capacityUsed: z.ZodOptional<z.ZodNumber>;
+    capacityTotal: z.ZodOptional<z.ZodNumber>;
+    indexStatus: z.ZodOptional<z.ZodEnum<{
+        complete: "complete";
+        failed: "failed";
+        running: "running";
+        idle: "idle";
+    }>>;
+    indexProgress: z.ZodOptional<z.ZodNumber>;
+    indexCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+export declare const openListExternalConnectSchema: z.ZodReadonly<z.ZodObject<{
+    endpoint: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare const openListMountCreateSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    mountPath: z.ZodString;
+    driver: z.ZodString;
+    addition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    order: z.ZodOptional<z.ZodNumber>;
+    remark: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare const openListMountInputSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>>;
+export declare const openListDisableMountSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
+export declare const openListUpgradeInputSchema: z.ZodReadonly<z.ZodObject<{
+    rollback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
 export declare const REFERENCE_ANYTHING_INVOCATIONS: readonly InvocationDescriptor[];

package/lib/contract.js

@@ -1,5 +1,31 @@
 import { z } from 'zod';
-import { providerSchema, referenceUiModeSchema, settingsRecordSchema } from "./wire.js";
+import { localAgentSchema, providerSchema, settingsRecordSchema } from "./wire.js";
+/**
+ * One local-agent transcript as the `@` menu sees it.
+ *
+ * `id` is the source-scoped `kind:relPath`, not a `dsh-ref:` URI — the client
+ * wraps it, the way it does for web chats, so the `'local-agent'` source string
+ * stays hardcoded in exactly one place. Deliberately carries no `origin`: the
+ * absolute path adds nothing a menu row can use and everything a screen-share
+ * leaks.
+ */
+export const agentCandidateSchema = z.object({ id: z.string(), kind: z.string(), label: z.string(), provider: z.string(), updatedAt: z.number().optional() }).readonly();
+export const agentStatsSchema = z.object({ agent: localAgentSchema, conversations: z.number().int().nonnegative() }).readonly();
+// `origin` is the drive's own display path, shown under the candidate. It is
+// never a download URL: those are signed with the account's credential and
+// must not cross this wire.
+export const driveCandidateSchema = z.object({
+    id: z.string(), label: z.string(), provider: z.string(),
+    origin: z.string().optional(), updatedAt: z.number().optional(),
+    searchIncomplete: z.boolean().optional(), isDirectory: z.boolean().optional(),
+}).strict().readonly();
+/**
+ * Binds the calling session to the invocation, so the Host can scope a search
+ * to the session's cwd. Reintroduced here after 0.3.0 handed file and session
+ * lookup back to DSH's native Remotes and removed its last other caller.
+ */
+const agentLookup = { name: 'agent', wire: 'agentId', source: 'lookup', lookup: 'agent',
+    codec: { mode: 'strict', typeSymbol: '@deepseek-ai/dsh-session/types#SessionId', schema: z.string().min(1) } };
 export const searchInputSchema = z.object({
     query: z.string(), provider: providerSchema.optional(), limit: z.number().int().min(1).max(100),
 }).readonly();
@@ -24,13 +50,11 @@ export const openCliDiscoverySchema = z.object({
 }).readonly();
 export const packageUpdateStatusSchema = z.object({
     currentVersion: z.string(), latestVersion: z.string(), updateAvailable: z.boolean(),
-    checkedAt: z.number().int().nonnegative(), error: z.string().optional(),
+    checkedAt: z.number().int().nonnegative(), releaseNotes: z.string().max(12_000).optional(), releaseUrl: z.string().url().optional(), error: z.string().optional(),
 }).readonly();
 export const packageUpdateResultSchema = z.object({
     version: z.string(), restartRequired: z.boolean(),
 }).readonly();
-export const referenceUiModeInputSchema = z.object({ mode: referenceUiModeSchema }).readonly();
-export const referenceUiSwitchResultSchema = z.object({ mode: referenceUiModeSchema, restartRequired: z.literal(false) }).readonly();
 export const providerStatsSchema = z.object({
     provider: providerSchema, conversations: z.number().int().nonnegative(), lastSyncedAt: z.string(),
     status: z.enum(['ready', 'syncing', 'error', 'empty']), error: z.string().optional(),
@@ -64,12 +88,39 @@ export const storageStatsSchema = z.object({
     remoteMissing: z.number().int().nonnegative().default(0), oldAccountConversations: z.number().int().nonnegative().default(0),
 }).readonly();
 export const clearProviderInputSchema = z.object({ provider: providerSchema }).readonly();
-export const clearOlderInputSchema = z.object({ days: z.number().int().min(1).max(36500) }).readonly();
 export const providerSyncStateSchema = z.object({
     provider: providerSchema, status: z.enum(['idle', 'running', 'cancelled', 'failed']),
     lastSyncAt: z.string(), lastCompleteScanAt: z.string(), error: z.string(),
 }).readonly();
+// OpenList wire DTOs intentionally omit every credential, storage addition,
+// raw/signed URL, and server-supplied diagnostic.  The Host keeps those in its
+// restricted credential file and translates failures to a generic message.
+export const openListStatusSchema = z.object({
+    state: z.enum(['install', 'downloading', 'running', 'failed', 'upgrade']), installed: z.boolean(),
+    mode: z.enum(['managed', 'external']).optional(), version: z.string().optional(), endpoint: z.string().optional(),
+    supportsRollback: z.boolean(), upgradeAvailable: z.boolean(), newerVersion: z.boolean().optional(), error: z.string().optional(),
+}).strict().readonly();
+export const openListDriverFieldSchema = z.object({
+    name: z.string(), label: z.string(), type: z.enum(['text', 'password', 'number', 'boolean', 'select']), secret: z.boolean(), required: z.boolean(), hasDefault: z.boolean().optional(), default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    options: z.array(z.object({ label: z.string(), value: z.string() }).readonly()).optional(),
+}).strict().readonly();
+export const openListDriverSchema = z.object({ name: z.string(), description: z.string().optional(), quickAuth: z.boolean(), fields: z.array(openListDriverFieldSchema) }).strict().readonly();
+export const openListMountSchema = z.object({
+    id: z.string(), name: z.string(), driver: z.string(), enabled: z.boolean(), status: z.enum(['ready', 'disabled', 'error']).optional(), error: z.string().optional(),
+    capacityUsed: z.number().nonnegative().optional(), capacityTotal: z.number().nonnegative().optional(),
+    indexStatus: z.enum(['idle', 'running', 'complete', 'failed']).optional(), indexProgress: z.number().min(0).max(1).optional(), indexCount: z.number().nonnegative().optional(),
+}).strict().readonly();
+export const openListExternalConnectSchema = z.object({ endpoint: z.string().min(1), username: z.string().optional(), password: z.string().optional(), token: z.string().optional() }).strict().readonly();
+export const openListMountCreateSchema = z.object({ id: z.string().min(1).optional(), mountPath: z.string().min(1), driver: z.string().min(1), addition: z.record(z.string(), z.unknown()), order: z.number().int().optional(), remark: z.string().optional() }).strict().readonly();
+export const openListMountInputSchema = z.object({ id: z.string().min(1) }).strict().readonly();
+export const openListDisableMountSchema = z.object({ id: z.string().min(1), disabled: z.boolean().optional() }).strict().readonly();
+export const openListUpgradeInputSchema = z.object({ rollback: z.boolean().optional() }).strict().readonly();
 export const REFERENCE_ANYTHING_INVOCATIONS = [
+    descriptor('agentSearch', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('AgentSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100) }).readonly()) }], strict('AgentCandidate[]', z.array(agentCandidateSchema)), true),
+    descriptor('agentStats', [], strict('AgentStats[]', z.array(agentStatsSchema)), true),
+    // No session lookup, unlike `agentSearch`: a drive is the same drive from
+    // every workspace, so there is nothing to scope the query to.
+    descriptor('driveSearch', [{ name: 'input', wire: 'input', source: 'json', codec: strict('DriveSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100) }).readonly()) }], strict('DriveCandidate[]', z.array(driveCandidateSchema)), true),
     descriptor('search', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SearchInput', searchInputSchema) }], strict('SearchResult[]', z.array(searchResultSchema)), true),
     descriptor('health', [], strict('Health', healthSchema), true),
     descriptor('quickHealth', [], strict('Health', healthSchema), true),
@@ -81,21 +132,31 @@ export const REFERENCE_ANYTHING_INVOCATIONS = [
     descriptor('updateStatus', [], strict('PackageUpdateStatus', packageUpdateStatusSchema), true),
     descriptor('checkUpdate', [], strict('PackageUpdateStatus', packageUpdateStatusSchema), true),
     descriptor('installUpdate', [], strict('PackageUpdateResult', packageUpdateResultSchema), true),
-    descriptor('switchReferenceUiMode', [{ name: 'input', wire: 'input', source: 'json', codec: strict('ReferenceUiModeInput', referenceUiModeInputSchema) }], strict('ReferenceUiSwitchResult', referenceUiSwitchResultSchema), true),
     descriptor('stats', [], strict('ProviderStats[]', z.array(providerStatsSchema))),
     descriptor('syncStart', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SyncStart', syncStartSchema) }], strict('JobId', z.string())),
     descriptor('syncStatus', [{ name: 'input', wire: 'input', source: 'json', codec: strict('JobInput', jobInputSchema) }], strict('SyncStatus?', syncStatusSchema.optional())),
     descriptor('syncCancel', [{ name: 'input', wire: 'input', source: 'json', codec: strict('JobInput', jobInputSchema) }], strict('Boolean', z.boolean())),
     descriptor('settingsGet', [], strict('Settings', settingsRecordSchema)),
     descriptor('settingsUpdate', [{ name: 'settings', wire: 'settings', source: 'json', codec: strict('Settings', settingsRecordSchema) }], strict('Settings', settingsRecordSchema)),
+    descriptor('openDownloadDirectory', [], strict('Boolean', z.boolean()), true),
     descriptor('browse', [{ name: 'input', wire: 'input', source: 'json', codec: strict('BrowseInput', browseInputSchema) }], strict('BrowsePage', browsePageSchema), true),
     descriptor('deleteConversation', [{ name: 'input', wire: 'input', source: 'json', codec: strict('DeleteInput', deleteInputSchema) }], strict('Boolean', z.boolean()), true),
     descriptor('storageStats', [], strict('StorageStats', storageStatsSchema)),
     descriptor('clearProvider', [{ name: 'input', wire: 'input', source: 'json', codec: strict('ClearProviderInput', clearProviderInputSchema) }], strict('Count', z.number().int().nonnegative()), true),
-    descriptor('clearOlder', [{ name: 'input', wire: 'input', source: 'json', codec: strict('ClearOlderInput', clearOlderInputSchema) }], strict('Count', z.number().int().nonnegative()), true),
     descriptor('clearRemoteMissing', [], strict('Count', z.number().int().nonnegative()), true),
     descriptor('clearOldAccounts', [], strict('Count', z.number().int().nonnegative()), true),
     descriptor('syncStates', [], strict('ProviderSyncState[]', z.array(providerSyncStateSchema))),
+    descriptor('openListStatus', [], strict('OpenListStatus', openListStatusSchema), true),
+    descriptor('openListInstall', [], strict('OpenListStatus', openListStatusSchema), true),
+    descriptor('openListUpgrade', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListUpgradeInput', openListUpgradeInputSchema) }], strict('OpenListStatus', openListStatusSchema), true),
+    descriptor('openListConnectExternal', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListExternalConnect', openListExternalConnectSchema) }], strict('OpenListStatus', openListStatusSchema), true),
+    descriptor('openListDisconnect', [], strict('OpenListStatus', openListStatusSchema), true),
+    descriptor('openListDrivers', [], strict('OpenListDriver[]', z.array(openListDriverSchema)), true),
+    descriptor('openListMounts', [], strict('OpenListMount[]', z.array(openListMountSchema)), true),
+    descriptor('openListCreateMount', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListMountCreate', openListMountCreateSchema) }], strict('OpenListMount', openListMountSchema), true),
+    descriptor('openListDisableMount', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListDisableMountInput', openListDisableMountSchema) }], strict('Boolean', z.boolean()), true),
+    descriptor('openListRemoveMount', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListMountInput', openListMountInputSchema) }], strict('Boolean', z.boolean()), true),
+    descriptor('openListReindex', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListMountInput', openListMountInputSchema) }], strict('OpenListReindex', z.object({ supported: z.boolean(), reason: z.string().optional() }).readonly()), true),
 ];
 function strict(type, schema) {
     return { mode: 'strict', typeSymbol: `dsh-reference-anything#${type}`, schema };

package/lib/download-directory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unlike `path.isAbsolute`, this excludes Windows paths rooted on the current
+ * drive (`\foo`) and drive-relative paths (`C:foo`). Those forms can silently
+ * resolve somewhere other than the directory displayed in Settings.
+ */
+export declare function isFullyQualifiedDownloadDirectory(value: string, platform?: NodeJS.Platform): boolean;
+/** Append an mkdtemp prefix without lexically resolving symlinks or `..`. */
+export declare function appendDownloadDirectoryPrefix(directory: string, prefix: string, platform?: NodeJS.Platform): string;
+export interface DownloadDirectoryValidationOptions {
+    platform?: NodeJS.Platform;
+    lstatPath?: (path: string) => Promise<{
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+    }>;
+    accessPath?: (path: string, mode: number) => Promise<void>;
+}
+/** Validate the user-selected base without changing its filesystem semantics. */
+export declare function validateDownloadDirectory(value: string, options?: DownloadDirectoryValidationOptions): Promise<string>;

package/lib/download-directory.js

@@ -0,0 +1,55 @@
+import { constants } from 'node:fs';
+import { access, lstat } from 'node:fs/promises';
+import { ReferenceAnythingError } from "./errors.js";
+/**
+ * Unlike `path.isAbsolute`, this excludes Windows paths rooted on the current
+ * drive (`\foo`) and drive-relative paths (`C:foo`). Those forms can silently
+ * resolve somewhere other than the directory displayed in Settings.
+ */
+export function isFullyQualifiedDownloadDirectory(value, platform = process.platform) {
+    if (platform !== 'win32')
+        return value.startsWith('/');
+    // Device and NT namespaces bypass ordinary filesystem parsing and can name
+    // objects outside the selected volume/share boundary. This feature only
+    // accepts conventional DOS drive paths and UNC shares.
+    if (/^\\\\[?.][\\/]/.test(value))
+        return false;
+    if (/^[A-Za-z]:[\\/]/.test(value))
+        return true;
+    return /^\\\\[^\\/]+[\\/][^\\/]+(?:[\\/].*)?$/.test(value);
+}
+/** Append an mkdtemp prefix without lexically resolving symlinks or `..`. */
+export function appendDownloadDirectoryPrefix(directory, prefix, platform = process.platform) {
+    if (!isFullyQualifiedDownloadDirectory(directory, platform) || directory.includes('\0')) {
+        throw new ReferenceAnythingError('Cloud-drive download directory is invalid', 'REFERENCE_INVALID_CONFIG');
+    }
+    if (prefix === '' || prefix === '.' || prefix === '..' || prefix.includes('\0') || /[\\/]/.test(prefix)) {
+        throw new ReferenceAnythingError('Cloud-drive temporary-directory prefix is invalid', 'REFERENCE_INVALID_CONFIG');
+    }
+    const hasSeparator = platform === 'win32' ? /[\\/]$/.test(directory) : directory.endsWith('/');
+    return `${directory}${hasSeparator ? '' : platform === 'win32' ? '\\' : '/'}${prefix}`;
+}
+/** Validate the user-selected base without changing its filesystem semantics. */
+export async function validateDownloadDirectory(value, options = {}) {
+    if (value === '')
+        return '';
+    const platform = options.platform ?? process.platform;
+    if (value.includes('\0') || !isFullyQualifiedDownloadDirectory(value, platform)) {
+        throw new ReferenceAnythingError('Cloud-drive download directory must be a fully-qualified absolute path', 'REFERENCE_INVALID_CONFIG');
+    }
+    const lstatPath = options.lstatPath ?? (async (path) => lstat(path));
+    const accessPath = options.accessPath ?? (async (path, mode) => access(path, mode));
+    try {
+        const metadata = await lstatPath(value);
+        if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+            throw new ReferenceAnythingError('Cloud-drive download directory must name a real directory, not a symbolic link', 'REFERENCE_INVALID_CONFIG');
+        }
+        await accessPath(value, constants.W_OK | constants.X_OK);
+    }
+    catch (cause) {
+        if (cause instanceof ReferenceAnythingError)
+            throw cause;
+        throw new ReferenceAnythingError('Cloud-drive download directory does not exist or is not writable', 'REFERENCE_INVALID_CONFIG', { cause });
+    }
+    return value;
+}

package/lib/errors.d.ts

@@ -16,8 +16,12 @@ export type ReferenceErrorCode =
  | 'REFERENCE_NOT_FOUND'
 /** A live browser read targeted a conversation owned by another account. */
  | 'REFERENCE_ACCOUNT_MISMATCH'
+/** The active provider account temporarily refused identity verification due to rate limiting. */
+ | 'PROVIDER_RATE_LIMIT'
 /** The source failed while reading; its own error is the `cause`. */
  | 'REFERENCE_READ_FAILED'
+/** A transcript whose format must be read whole is larger than the scan budget. */
+ | 'REFERENCE_TRANSCRIPT_TOO_LARGE'
 /** The caller cancelled before the read settled. */
  | 'REFERENCE_CANCELLED'
 /** A `dsh-ref:` URI was malformed, non-canonical, or not a reference at all. */

package/lib/host.d.ts

@@ -1,10 +1,53 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { ChatProvider, SettingsRecord } from './store/spec.ts';
-import type { ReferenceUiMode } from './wire.ts';
 import type { SyncMode } from './sync/index.ts';
+import type { Agent } from '@deepseek-ai/dsh-agent';
 export declare class ReferenceAnythingRemote extends TypertRemoteService {
     constructor(ctx: Context);
+    /**
+     * Discovery for the `@` menu's local-agent group.
+     *
+     * Resolved optionally rather than injected: `reference-anything-web` must
+     * still load in a profile where the local-agent plugin is switched off, and an
+     * absent service means an empty group, not a broken composer. Workspace
+     * scoping takes the session's own cwd, so a Web server serving projects from
+     * anywhere still scopes to the project the user is in.
+     */
+    agentSearch(agent: Agent, input: {
+        query: string;
+        limit: number;
+    }, signal: AbortSignal): Promise<{
+        searchIncomplete?: boolean | undefined;
+        updatedAt?: number | undefined;
+        id: string;
+        kind: string;
+        label: string;
+        provider: string;
+    }[]>;
+    agentStats(signal: AbortSignal): Promise<{
+        agent: import("./sources/local-agent/types.ts").AgentKind;
+        conversations: number;
+    }[]>;
+    /**
+     * Discovery for the `@` menu's cloud-drive group.
+     *
+     * Optional for the same reason as `agentSearch` above. It takes no session:
+     * a drive is not scoped to a workspace, so there is nothing a cwd could
+     * narrow. `list` already refuses to name a download URL, so what comes back
+     * here is a label and a display path.
+     */
+    driveSearch(input: {
+        query: string;
+        limit: number;
+    }, signal: AbortSignal): Promise<{
+        isDirectory?: boolean | undefined;
+        updatedAt?: number | undefined;
+        origin?: string | undefined;
+        id: string;
+        label: string;
+        provider: string;
+    }[]>;
     search(input: {
         query: string;
         provider?: ChatProvider;
@@ -20,9 +63,6 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     updateStatus(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateStatus>;
     checkUpdate(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateStatus>;
     installUpdate(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateResult>;
-    switchReferenceUiMode(input: {
-        mode: ReferenceUiMode;
-    }, signal: AbortSignal): Promise<import("./profile-mode.ts").ReferenceUiSwitchResult>;
     stats(): import("./store/store.ts").ProviderStats[];
     syncStart(input: {
         providers: ChatProvider[];
@@ -38,15 +78,19 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     settingsUpdate(settings: SettingsRecord): Promise<{
         opencliPath: string;
         profile: string;
+        cloudDriveDownloadDirectory: string;
         detailConcurrency: number;
         autoSync: boolean;
         syncOnStartup: boolean;
         autoSyncMinutes: number;
         historyMode: "metadata-only" | "offline-mirror";
+        syncHistoryDays: number | 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" | "raw-text";
-        referenceUiMode?: "plugin" | "official" | undefined;
+        agentDirectories?: Partial<Record<"kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode", string>> | undefined;
+        enabledDriveMounts?: string[] | undefined;
         picker?: {
             displayMode: "collapse" | "native-scroll";
             commands: {
@@ -73,14 +117,27 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
                 limit: number;
                 maxCandidates: number;
             };
+            agents: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+                maxCandidates: number;
+            };
             conversations: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
             };
+            drives: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+                maxCandidates: number;
+            };
         } | undefined;
     }>;
+    openDownloadDirectory(signal: AbortSignal): Promise<boolean>;
     browse(input: {
         query: string;
         provider?: ChatProvider;
@@ -97,10 +154,41 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     clearProvider(input: {
         provider: ChatProvider;
     }, signal: AbortSignal): Promise<number>;
-    clearOlder(input: {
-        days: number;
-    }, signal: AbortSignal): Promise<number>;
     clearRemoteMissing(signal: AbortSignal): Promise<number>;
     clearOldAccounts(signal: AbortSignal): Promise<number>;
     syncStates(): import("./store/store.ts").ProviderSyncState[];
+    openListStatus(signal: AbortSignal): Promise<import("./openlist/index.ts").OpenListStatus>;
+    openListInstall(signal: AbortSignal): Promise<import("./openlist/index.ts").OpenListStatus>;
+    openListUpgrade(input: {
+        rollback?: boolean;
+    }, signal: AbortSignal): Promise<import("./openlist/index.ts").OpenListStatus>;
+    openListConnectExternal(input: {
+        endpoint: string;
+        username?: string;
+        password?: string;
+        token?: string;
+    }, signal: AbortSignal): Promise<import("./openlist/index.ts").OpenListStatus>;
+    openListDisconnect(signal: AbortSignal): Promise<import("./openlist/index.ts").OpenListStatus>;
+    openListDrivers(signal: AbortSignal): Promise<import("./openlist/host.ts").OpenListDriver[]>;
+    openListMounts(signal: AbortSignal): Promise<import("./openlist/host.ts").OpenListMount[]>;
+    openListCreateMount(input: {
+        id?: string;
+        mountPath: string;
+        driver: string;
+        addition: Record<string, unknown>;
+        order?: number;
+        remark?: string;
+    }, signal: AbortSignal): Promise<import("./openlist/host.ts").OpenListMount>;
+    openListDisableMount(input: {
+        id: string;
+        disabled?: boolean;
+    }, signal: AbortSignal): Promise<boolean>;
+    openListRemoveMount(input: {
+        id: string;
+    }, signal: AbortSignal): Promise<boolean>;
+    openListReindex(input: {
+        id: string;
+    }, signal: AbortSignal): Promise<{
+        supported: true;
+    }>;
 }