@ai-workbench/remote-agent 0.8.2 → 0.8.10

package/dist/recovery-checkpoint.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { RuntimeRequest } from './provider.ts';
+/** A step's accepted batch follows step/start in the official event contract. */
+export declare function currentInputIds(ctx: Context, request: RuntimeRequest): Promise<readonly string[]>;
+/** Read only the official persistence API after its awaited durability checkpoint. */
+export declare function verifyRecoveryCheckpoint(ctx: Context, request: RuntimeRequest, provider: string): Promise<boolean>;

package/dist/recovery-checkpoint.js

@@ -0,0 +1,71 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { BlockAssembler, expandAssistantStream } from '@deepseek-ai/dsh-llm';
+import { isDeepStrictEqual } from 'node:util';
+/** A step's accepted batch follows step/start in the official event contract. */
+export async function currentInputIds(ctx, request) {
+    if (!request.sessionId)
+        return [];
+    const id = SessionId(request.sessionId), store = ctx.get('sessions'), session = store?.get(id);
+    const persistence = ctx.get('sessionPersistence');
+    if (!session || !store || !persistence || !await store.flush(session))
+        return [];
+    const handle = await persistence.open(id, 'read');
+    try {
+        if (handle.id !== id || handle.header?.id !== id || handle.access !== 'read')
+            return [];
+        const { events } = await handle.read();
+        if (!Array.isArray(events))
+            return [];
+        let step;
+        let ids = [];
+        for (const event of events) {
+            if (event.type === 'step/start') {
+                step = event;
+                ids = [];
+            }
+            else if (event.type === 'turn/start' || event.type === 'step/end' || event.type === 'turn/end') {
+                step = undefined;
+                ids = [];
+            }
+            else if (event.type === 'user/message' && step)
+                ids.push(event.data.id);
+        }
+        return ids;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Read only the official persistence API after its awaited durability checkpoint. */
+export async function verifyRecoveryCheckpoint(ctx, request, provider) {
+    if (!request.sessionId || !request.recoveryCheckpointId || !request.resumeSessionId)
+        return false;
+    const id = SessionId(request.sessionId), store = ctx.get('sessions'), session = store?.get(id);
+    const persistence = ctx.get('sessionPersistence');
+    if (!session || typeof store?.flush !== 'function' || typeof persistence?.open !== 'function')
+        return false;
+    if (!await store.flush(session))
+        return false;
+    const handle = await persistence.open(id, 'read');
+    try {
+        if (handle?.id !== id || handle.header?.id !== id || handle.access !== 'read')
+            return false;
+        const { events } = await handle.read();
+        if (!Array.isArray(events))
+            return false;
+        const final = events.findLast(e => e.type === 'assistant/message' && e.surfaceOp === 'append');
+        const live = session.deriveMessages().findLast(m => m.role === 'assistant');
+        if (final?.type !== 'assistant/message' || final.data.interrupted || !live || live.id !== final.data.message.id || !isDeepStrictEqual(live, final.data.message))
+            return false;
+        const message = final.data.message, pointer = message.source.replayState?.response;
+        if (message.source.provider !== provider || pointer?.agent !== provider || pointer.dshSessionId !== id || pointer.sessionId !== request.resumeSessionId || pointer.recoveryCheckpointId !== request.recoveryCheckpointId)
+            return false;
+        const assembled = new BlockAssembler();
+        for (const part of expandAssistantStream(final.data.stream))
+            assembled.push(part.chunk);
+        return ['stop', 'max-tokens'].includes(assembled.finish.kind) && isDeepStrictEqual(assembled.replayState, message.source.replayState) && isDeepStrictEqual(assembled.blocks(), message.content);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/recovery.d.ts

@@ -0,0 +1,47 @@
+import type { AgentCapabilities, SessionConfigOption } from '@agentclientprotocol/sdk/unstable';
+export interface AcpRecovery {
+    sessionId: string;
+    capabilities: AgentCapabilities;
+    modelConfiguration?: {
+        configOptions: SessionConfigOption[];
+        resolvedEvidence?: {
+            modelValue: string;
+            resolvedModel: string;
+        };
+    };
+    configUpdates?: SessionConfigOption[][];
+}
+export interface RecoveryState {
+    version: 1;
+    phase: 'dirty' | 'clean' | 'ended';
+    scope: string;
+    brokerId: string;
+    instanceId?: string;
+    pid?: number;
+    cursor?: number;
+    checkpointId?: string;
+    acp?: AcpRecovery;
+}
+export interface RecoveryJournal {
+    read(): Promise<RecoveryState | undefined>;
+    write(state: RecoveryState): Promise<void>;
+}
+export declare function validateRecovery(value: unknown): RecoveryState;
+export declare const codexContextPolicy: Readonly<{
+    version: 1;
+    scope: "new-session";
+    mode: "append";
+    content: "text";
+    resume: "omit-only";
+    changed: "new-session-required";
+    mapping: "developerInstructions";
+    nativeCliUnmodified: true;
+}>;
+export declare function supportsCodexContextPolicy(capabilities: AgentCapabilities): boolean;
+/** Known capabilities plus the exact Codex policy whitelist; no arbitrary metadata. */
+export declare function recoveryCapabilities(c: AgentCapabilities): AgentCapabilities;
+export declare function recoveryKey(value: unknown): string;
+/** Preserve legacy lookup bytes; each employee endpoint scope owns a separate journal. */
+export declare function runtimeRecoveryKey(identity: string, provider: string, sessionId: string | undefined, employeeScope?: string): string;
+/** History is immutable; current is atomically replaced only after fsync. No expiry. */
+export declare function recoveryJournal(profileDir: string, key: string): RecoveryJournal;

package/dist/recovery.js

@@ -0,0 +1,61 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { open, rename } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { privateDirectory, durableWrite, readJournal } from "./remote-details.js";
+import { NeedError } from "./remote.js";
+const invalid = () => new NeedError('RECOVERY_STORAGE_INVALID', '会话恢复记录无效，本轮尚未发送', '有效的私有会话恢复记录');
+export function validateRecovery(value) {
+    const s = value;
+    if (!s || s.version !== 1 || !['dirty', 'clean', 'ended'].includes(s.phase) || !/^[a-f0-9]{64}$/.test(s.scope) || !/^r[a-f0-9]{23}$/.test(s.brokerId))
+        throw invalid();
+    if (s.instanceId !== undefined && !/^[a-f0-9-]{36}$/.test(s.instanceId) || s.pid !== undefined && (!Number.isSafeInteger(s.pid) || s.pid < 1))
+        throw invalid();
+    if (s.phase === 'clean' && (!s.instanceId || !Number.isSafeInteger(s.cursor) || s.cursor < 0 || typeof s.checkpointId !== 'string' || !s.checkpointId || !s.acp || typeof s.acp.sessionId !== 'string' || !s.acp.sessionId || !s.acp.capabilities || typeof s.acp.capabilities !== 'object' || Array.isArray(s.acp.capabilities)))
+        throw invalid();
+    return structuredClone(s);
+}
+export const codexContextPolicy = Object.freeze({ version: 1, scope: 'new-session', mode: 'append', content: 'text', resume: 'omit-only', changed: 'new-session-required', mapping: 'developerInstructions', nativeCliUnmodified: true });
+export function supportsCodexContextPolicy(capabilities) {
+    const policy = capabilities._meta?.aiWorkbenchSystemPrompt;
+    return !!policy && typeof policy === 'object' && !Array.isArray(policy) && Object.keys(policy).length === Object.keys(codexContextPolicy).length && Object.entries(codexContextPolicy).every(([key, value]) => policy[key] === value);
+}
+/** Known capabilities plus the exact Codex policy whitelist; no arbitrary metadata. */
+export function recoveryCapabilities(c) {
+    return { loadSession: c.loadSession === true, promptCapabilities: { image: c.promptCapabilities?.image === true, audio: c.promptCapabilities?.audio === true, embeddedContext: c.promptCapabilities?.embeddedContext === true }, sessionCapabilities: { ...(c.sessionCapabilities?.resume ? { resume: {} } : {}), ...(c.sessionCapabilities?.systemPrompt ? { systemPrompt: {} } : {}) }, ...(supportsCodexContextPolicy(c) ? { _meta: { aiWorkbenchSystemPrompt: { ...codexContextPolicy } } } : {}) };
+}
+export function recoveryKey(value) { return createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
+/** Preserve legacy lookup bytes; each employee endpoint scope owns a separate journal. */
+export function runtimeRecoveryKey(identity, provider, sessionId, employeeScope) {
+    return recoveryKey([identity, provider, sessionId, ...(employeeScope ? ['employee', employeeScope] : [])]);
+}
+/** History is immutable; current is atomically replaced only after fsync. No expiry. */
+export function recoveryJournal(profileDir, key) {
+    if (!/^[a-f0-9]{64}$/.test(key))
+        throw invalid();
+    const parent = join(profileDir, 'ai-workbench-remote-agent'), dir = join(parent, 'recovery', key), current = join(dir, 'current.json');
+    let tail = Promise.resolve();
+    const prepare = async () => { await privateDirectory(parent); await privateDirectory(join(parent, 'recovery')); await privateDirectory(dir); };
+    return {
+        async read() { await tail; await prepare(); try {
+            return validateRecovery(await readJournal(current));
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return;
+            throw error;
+        } },
+        write(state) { const value = validateRecovery(state); const task = tail.then(async () => { await prepare(); const id = randomUUID(); await durableWrite(join(dir, id + '.json'), value); const temp = join(dir, id + '.current'); const file = await open(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); try {
+            await file.writeFile(JSON.stringify(value) + '\n');
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        } await rename(temp, current); const directory = await open(dir, 'r'); try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        } }); tail = task; return task; },
+    };
+}

package/dist/remote-details.d.ts

@@ -18,11 +18,21 @@ export interface DetailRequest {
     provider: 'claude' | 'codex';
     identity: string;
     connection: Connection;
+    readonly localAcceptanceId?: string;
 }
+export declare function privateDirectory(path: string): Promise<void>;
+export declare function durableWrite(path: string, value: unknown): Promise<void>;
+export declare function readJournal(path: string): Promise<unknown>;
 export declare function createRemoteDetails(options: {
     profileDir: string;
     getApi: () => RemoteDetailsApi | undefined;
 }): {
+    recordLocalFailure(request: {
+        sessionId?: string;
+        provider: "claude" | "codex";
+        code: string;
+        observation?: DetailObservation;
+    }): Promise<void>;
     recordLoginFailure(request: {
         sessionId?: string;
         code: string;

package/dist/remote-details.js

@@ -23,7 +23,7 @@ function kind(observation) {
         return observation.severity === 'action-required' ? 'action-required' : 'unknown';
     return { extension: 'extensions', tool: 'tools', need: 'action-required', notice: 'extensions', session: 'extensions' }[observation.kind] ?? observation.kind;
 }
-async function privateDirectory(path) {
+export async function privateDirectory(path) {
     if (!isAbsolute(path))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
     // Existing parent/profile ownership is the host's responsibility; reject symlinks
@@ -57,7 +57,7 @@ async function privateDirectory(path) {
     if ((info.mode & 0o077) !== 0 || (process.getuid && info.uid !== process.getuid()))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
 }
-async function durableWrite(path, value) {
+export async function durableWrite(path, value) {
     const file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
     try {
         await file.writeFile(JSON.stringify(value) + '\n');
@@ -74,7 +74,7 @@ async function durableWrite(path, value) {
         await parent.close();
     }
 }
-async function readJournal(path) {
+export async function readJournal(path) {
     const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const info = await file.stat();
@@ -91,6 +91,12 @@ export function createRemoteDetails(options) {
     const scopes = new Map(), loginScopes = new Map();
     const initialize = async () => { await privateDirectory(join(options.profileDir, 'ai-workbench-remote-agent')); await privateDirectory(root); };
     return {
+        async recordLocalFailure(request) {
+            await initialize();
+            if (!/^[A-Z][A-Z0-9_]*$/.test(request.code))
+                throw failure('REMOTE_DETAIL_STORAGE_FAILED');
+            await durableWrite(join(root, randomUUID() + '.json'), { version: 1, kind: 'local-admission', code: request.code, provider: request.provider, sessionHash: request.sessionId ? hash(request.sessionId) : null, ...request.observation ? { observation: sanitizeObservation(request.observation, true) } : {} });
+        },
         async recordLoginFailure(request) {
             await initialize();
             const eventId = randomUUID(), diagnostic = request.diagnostic;
@@ -221,6 +227,10 @@ export function createRemoteDetails(options) {
             return { eventId, recorded: true };
         },
         async open(request) {
+            request = structuredClone(request);
+            if (request.localAcceptanceId !== undefined && (typeof request.localAcceptanceId !== 'string' || !request.localAcceptanceId.trim()))
+                throw failure('REMOTE_DETAIL_SCOPE_INVALID');
+            const localScope = request.localAcceptanceId === undefined ? undefined : Object.freeze({ localAcceptanceId: request.localAcceptanceId });
             if (!request.sessionId || !request.identity || !request.connection.instanceId || !Number.isSafeInteger(request.connection.epoch) || request.connection.epoch < 0 || !['claude', 'codex'].includes(request.provider))
                 throw failure('REMOTE_DETAIL_SCOPE_INVALID');
             try {
@@ -348,7 +358,7 @@ export function createRemoteDetails(options) {
                         stable();
                         let response;
                         try {
-                            response = await api.appendRemoteConversationDetail(structuredClone(detail));
+                            response = await (localScope === undefined ? api.appendRemoteConversationDetail(structuredClone(detail)) : api.appendRemoteConversationDetail(structuredClone(detail), localScope));
                         }
                         catch {
                             stable();

package/dist/rpc-namespace.d.ts

@@ -0,0 +1,3 @@
+import type { Stream } from '@agentclientprotocol/sdk/unstable';
+/** Public Stream only. Server request/approval IDs are never changed. */
+export declare function isolateRpcIds(stream: Stream): Stream;

package/dist/rpc-namespace.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { NeedError } from "./remote.js";
+/** Public Stream only. Server request/approval IDs are never changed. */
+export function isolateRpcIds(stream) {
+    const prefix = randomUUID() + '/';
+    const pending = new Map();
+    const readable = stream.readable.pipeThrough(new TransformStream({ transform(message, controller) {
+            const raw = message;
+            if (!raw.method && Object.hasOwn(raw, 'id')) {
+                if (typeof raw.id !== 'string' || !pending.has(raw.id))
+                    throw new NeedError('ACP_FOREIGN_RESPONSE', '收到不属于当前客户端的协议响应', '原会话的完整客户端状态');
+                const id = pending.get(raw.id);
+                pending.delete(raw.id);
+                controller.enqueue({ ...raw, id });
+            }
+            else
+                controller.enqueue(message);
+        } }));
+    const writable = new WritableStream({ async write(message) {
+            const raw = message;
+            let outgoing = raw;
+            if (typeof raw.method === 'string' && Object.hasOwn(raw, 'id')) {
+                const id = prefix + JSON.stringify(raw.id);
+                pending.set(id, raw.id);
+                outgoing = { ...raw, id };
+            }
+            else if (raw.method === '$/cancel_request' && raw.params && typeof raw.params === 'object') {
+                const params = raw.params;
+                outgoing = { ...raw, params: { ...params, requestId: prefix + JSON.stringify(params.requestId) } };
+            }
+            const writer = stream.writable.getWriter();
+            try {
+                await writer.write(outgoing);
+            }
+            finally {
+                writer.releaseLock();
+            }
+        }, async close() { const writer = stream.writable.getWriter(); try {
+            await writer.close();
+        }
+        finally {
+            writer.releaseLock();
+        } }, async abort(reason) { const writer = stream.writable.getWriter(); try {
+            await writer.abort(reason);
+        }
+        finally {
+            writer.releaseLock();
+        } } });
+    return { readable, writable };
+}

package/dist/stage-timing.d.ts

@@ -0,0 +1,27 @@
+import type { DetailObservation } from './conversation-details.ts';
+export declare const STAGES: Readonly<{
+    readonly 'login-ready': "登录就绪检查";
+    readonly 'connection-confirm': "核对当前连接状态";
+    readonly 'input-prepare': "准备本轮输入";
+    readonly 'workspace-resolve': "解析工作区";
+    readonly 'details-open': "打开技术详情";
+    readonly 'details-flush': "等待技术详情持久确认";
+    readonly 'workspace-notice': "记录工作区说明";
+    readonly 'broker-list': "查询主机会话";
+    readonly 'broker-start': "启动主机会话";
+    readonly 'broker-attach': "连接主机会话";
+    readonly 'acp-initialize': "初始化远程模型";
+    readonly 'acp-session-new': "新建模型会话";
+    readonly 'acp-session-load': "加载模型会话";
+    readonly 'acp-session-resume': "恢复模型会话";
+    readonly 'acp-prompt': "模型处理本轮（含等待审批）";
+}>;
+export type Stage = keyof typeof STAGES;
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export declare class StageTiming {
+    private readonly started;
+    private pending;
+    private sink?;
+    bind(sink: (detail: DetailObservation) => void): void;
+    run<T>(phase: Stage, operation: () => Promise<T>): Promise<T>;
+}

package/dist/stage-timing.js

@@ -0,0 +1,39 @@
+export const STAGES = Object.freeze({
+    'login-ready': '登录就绪检查', 'connection-confirm': '核对当前连接状态', 'input-prepare': '准备本轮输入', 'workspace-resolve': '解析工作区',
+    'details-open': '打开技术详情', 'details-flush': '等待技术详情持久确认', 'workspace-notice': '记录工作区说明',
+    'broker-list': '查询主机会话', 'broker-start': '启动主机会话', 'broker-attach': '连接主机会话',
+    'acp-initialize': '初始化远程模型', 'acp-session-new': '新建模型会话',
+    'acp-session-load': '加载模型会话', 'acp-session-resume': '恢复模型会话',
+    'acp-prompt': '模型处理本轮（含等待审批）',
+});
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export class StageTiming {
+    started = performance.now();
+    pending = [];
+    sink;
+    bind(sink) {
+        this.sink = sink;
+        const pending = this.pending;
+        this.pending = [];
+        for (const detail of pending)
+            sink(detail);
+    }
+    async run(phase, operation) {
+        const started = performance.now();
+        let outcome = 'failed';
+        try {
+            const result = await operation();
+            outcome = 'ok';
+            return result;
+        }
+        finally {
+            const ended = performance.now();
+            const durationMs = ended - started, elapsedMs = ended - this.started;
+            const detail = { kind: 'session', severity: outcome === 'ok' ? 'info' : 'warning', code: 'REMOTE_STAGE_TIMING', summary: STAGES[phase] + '：' + durationMs.toFixed(1) + '毫秒', payload: { phase, durationMs, elapsedMs, outcome, clock: 'client-monotonic' } };
+            if (this.sink)
+                this.sink(detail);
+            else
+                this.pending.push(detail);
+        }
+    }
+}

package/helpers/ripgrep/LICENSE-vscode

@@ -0,0 +1,13 @@
+vscode-ripgrep
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/helpers/ripgrep/PROVENANCE.md

@@ -0,0 +1,9 @@
+# Bundled Mac search component
+
+Original unmodified binaries from Microsoft @vscode/ripgrep-universal 1.18.0. The npm integrity/SHA256, per-file SHA/bytes and upstream release archives are in manifest.json. Both npm binaries were compared byte for byte with the pinned Microsoft release assets (v15.0.1). No employee download/install hook or PATH lookup.
+
+Microsoft packaging tag v1.18.0 commit d22dec46c67fc8c5d307c9b18dba2792efd1f016 locks ripgrep-prebuilt v15.0.1 commit 67202aaafb17aecd9b5b7046d5b7baa92b05237a. Its config pins upstream ripgrep15.0.0 plus the retained Microsoft patch (Windows/ARM-musl adjustments); reported binaries are ripgrep15.0.0 with PCRE2 10.45. Upstream source: https://github.com/BurntSushi/ripgrep/tree/15.0.0 ; vendor source/config: https://github.com/microsoft/ripgrep-prebuilt/tree/v15.0.1 ; npm wrapper: https://github.com/microsoft/vscode-ripgrep/tree/v1.18.0 . Source-input hashes are retained in manifest.json. This is vendor artifact provenance, not a local reproducible build attestation; exact vendor compiler invocation/runtime std build was not independently attested.
+
+LICENSE-vscode retains Microsoft packaging MIT text. notices/ contains ripgrep MIT/Unlicense/COPYING, PCRE2 licence, and a conservative full upstream Cargo.lock dependency superset plus Microsoft's Windows-only msvc_spectre_libs. Every crate archive matches its Cargo checksum; DEPENDENCIES.json identifies original package, version, licence and retained texts. r-efi licence is embedded in AUTHORS. wasip2 texts omitted from its crate were retrieved at its .cargo_vcs_info.json exact source commit. Superset inclusion is not a claim all non-Mac/build/test crates are linked into these Mac binaries. prepare-ripgrep-notices.py regenerates notices from the retained pinned inputs.
+
+Runtime validates shipped rg size/SHA256, executable regular file, macOS arm64/x64 only. No strip/sign/byte alteration by X. Arm64 actual PCRE2 operation is fixture-tested; x64 is byte/inventory verified, not executed on this arm64 Mac. macOS SDK/system libraries are supplied by the OS; binaries have no Homebrew dylib dependency. The plugin message/output bound uses named acpMaxMessageBytes. Other platforms fail explicitly rather than host fallback.

package/helpers/ripgrep/manifest.json

@@ -0,0 +1,56 @@
+{
+  "npm": "@vscode/ripgrep-universal@1.18.0",
+  "source": "https://registry.npmjs.org/@vscode/ripgrep-universal/-/ripgrep-universal-1.18.0.tgz",
+  "archiveSha256": "76a03f429dc13a90f53b60995211a54308ab4f67b2521bac00f9c4be953dff52",
+  "integrity": "sha512-kgrAVy1L/v/8erAjo+I720ifTf7o4rvYUwgsuEu97XAEBtPT9sk3HhcSgFpxMydvNmwdJtXo9/AVee7JjocTrg==",
+  "files": {
+    "darwin-arm64": {
+      "bytes": 4528512,
+      "sha256": "6ef40346bf31fcce79d9614c7745c198542925a0c7d4911e1ffe794c53392ac1"
+    },
+    "darwin-x64": {
+      "bytes": 4742676,
+      "sha256": "f999495980a5e6f1e7d26461ef5768b4013a62df610ed7d77a8b2de247a5b228"
+    }
+  },
+  "vendorRelease": "microsoft/ripgrep-prebuilt@v15.0.1",
+  "vendorCommit": "67202aaafb17aecd9b5b7046d5b7baa92b05237a",
+  "sourceRipgrep": "BurntSushi/ripgrep@15.0.0",
+  "reportedVersion": "ripgrep 15.0.0 / PCRE2 10.45",
+  "sourceInputs": [
+    {
+      "file": "vscode-build.json",
+      "sha256": "fcf6b245175385854a06785ae990546fe0d197ceb65ec9ca58860a5817f07abd"
+    },
+    {
+      "file": "vscode-binaries.lock.json",
+      "sha256": "0bd421f46e3ee2f127290f67e73adb240e1311162d6d33c25121849e5f2beadc"
+    },
+    {
+      "file": "prebuilt-config.json",
+      "sha256": "71bc7b3ecdd5442001f74896a738eafb3b831ee5a183e128067fe6b6d6b64ea7"
+    },
+    {
+      "file": "prebuilt-build-build.sh",
+      "sha256": "cf0d97cafca064c763d3ceeebe8b2f7647f5b4b35710b37c74804a4d3e1b3929"
+    },
+    {
+      "file": "prebuilt-patches-0001-resolve-binskim-issues.patch",
+      "sha256": "45f8b58bba714c446de407f93120f557736b45fad6f43ea283077201646a1be7"
+    },
+    {
+      "file": "ripgrep-lock",
+      "sha256": "257bfa1eeacfa4d8222e2c50f9d2f8d15ef07e96adee46eaa87839f3b6cfa3b4"
+    }
+  ],
+  "vendorArchives": {
+    "darwin-arm64": {
+      "sha256": "2fa16464fd8638588a67c7fc172d3c4b57fbdc65dff366e10b0b0e90734628a6",
+      "url": "https://github.com/microsoft/ripgrep-prebuilt/releases/download/v15.0.1/ripgrep-v15.0.1-aarch64-apple-darwin.tar.gz"
+    },
+    "darwin-x64": {
+      "sha256": "591c693e80bb444ef1907b2a906feb9c77bcafe1cdf509107cc75dcf0e875bd2",
+      "url": "https://github.com/microsoft/ripgrep-prebuilt/releases/download/v15.0.1/ripgrep-v15.0.1-x86_64-apple-darwin.tar.gz"
+    }
+  }
+}

package/helpers/ripgrep/notices/COPYING-ripgrep

@@ -0,0 +1,3 @@
+This project is dual-licensed under the Unlicense and MIT licenses.
+
+You may use this code under the terms of either license.