@myagentroam/node 0.1.4 → 0.1.7

package/dist/service/workspace-workbench-service.js

@@ -1,8 +1,11 @@
-import { readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, restoreCurrentChange } from '../workspace.js';
+import { listGitHistoryRefs, readGitHistory, readGitHistoryFileDiff, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, restoreCurrentChange } from '../workspace.js';
+import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
 export class WorkspaceWorkbenchService {
     options;
+    contentSearch;
     constructor(options) {
         this.options = options;
+        this.contentSearch = new WorkspaceContentSearchService(options.files);
     }
     operations() {
         return {
@@ -12,6 +15,8 @@ export class WorkspaceWorkbenchService {
             'workspace.files.list': (data) => this.listFiles(record(data)),
             'workspace.file.read': (data) => this.readFile(record(data)),
             'workspace.files.search': (data) => this.searchFiles(record(data)),
+            'workspace.files.mutate': (data) => this.mutateFile(record(data)),
+            'workspace.content.search': (data) => this.searchContent(record(data)),
             'workspace.files.upload.preflight': (data) => this.preflight(record(data)),
             'workspace.files.upload.create': (data) => this.createUpload(record(data)),
             'workspace.files.upload.chunk': (data) => this.writeUpload(record(data)),
@@ -23,6 +28,10 @@ export class WorkspaceWorkbenchService {
             'workspace.changes.current': (data) => this.currentChanges(record(data)),
             'workspace.change.diff': (data) => this.changeDiff(record(data)),
             'workspace.change.restore': (data) => this.restoreChange(record(data)),
+            'workspace.git.refs.list': (data) => this.gitRefs(record(data)),
+            'workspace.git.history.list': (data) => this.gitHistory(record(data)),
+            'workspace.git.commit.files': (data) => this.gitCommitFiles(record(data)),
+            'workspace.git.commit.file.diff': (data) => this.gitCommitFileDiff(record(data)),
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
@@ -87,6 +96,14 @@ export class WorkspaceWorkbenchService {
         const workspace = this.options.requireWorkspace(input.workspaceId);
         return { files: await this.options.files.search(workspace, input) };
     }
+    async mutateFile(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { file: await this.options.files.mutate(workspace, input) };
+    }
+    async searchContent(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { search: await this.contentSearch.search(workspace, input) };
+    }
     async preflight(input) {
         return {
             uploads: await this.options.uploads.preflight(this.options.requireWorkspace(input.workspaceId), input)
@@ -133,6 +150,57 @@ export class WorkspaceWorkbenchService {
         this.options.invalidate(workspace.id);
         return { restored: true };
     }
+    async gitRepository(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            (input.repositoryPath !== undefined && typeof input.repositoryPath !== 'string'))
+            throw new Error('GIT_REPOSITORY_INVALID');
+        const workspace = this.gitWorkspace(input.workspaceId);
+        return resolveGitRepository(workspace.path, input.repositoryPath ?? '');
+    }
+    refs(input) {
+        if (input.refs === undefined)
+            return undefined;
+        if (!Array.isArray(input.refs) ||
+            input.refs.length > 128 ||
+            input.refs.some((ref) => typeof ref !== 'string'))
+            throw new Error('GIT_HISTORY_REF_INVALID');
+        return input.refs;
+    }
+    async gitRefs(input) {
+        return { refs: await listGitHistoryRefs(await this.gitRepository(input)) };
+    }
+    async gitHistory(input) {
+        const refs = this.refs(input);
+        if (input.cursor !== undefined && typeof input.cursor !== 'string')
+            throw new Error('GIT_HISTORY_CURSOR_INVALID');
+        if (input.limit !== undefined &&
+            (typeof input.limit !== 'number' ||
+                !Number.isInteger(input.limit) ||
+                input.limit < 1 ||
+                input.limit > 100))
+            throw new Error('GIT_HISTORY_LIMIT_INVALID');
+        return readGitHistory(await this.gitRepository(input), {
+            ...(refs === undefined ? {} : { refs }),
+            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
+            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
+        });
+    }
+    async gitCommitFiles(input) {
+        if (typeof input.commit !== 'string')
+            throw new Error('GIT_HISTORY_COMMIT_INVALID');
+        return {
+            files: await readGitHistoryFiles(await this.gitRepository(input), input.commit, this.refs(input))
+        };
+    }
+    async gitCommitFileDiff(input) {
+        if (typeof input.commit !== 'string' ||
+            typeof input.path !== 'string' ||
+            (input.previousPath !== undefined && typeof input.previousPath !== 'string'))
+            throw new Error('GIT_DIFF_INVALID');
+        return {
+            diff: await readGitHistoryFileDiff(await this.gitRepository(input), input.commit, input.path, this.refs(input), input.previousPath)
+        };
+    }
     async diff(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.fromRef !== 'string' ||
@@ -153,4 +221,3 @@ function record(value) {
         ? value
         : {};
 }
-//# sourceMappingURL=workspace-workbench-service.js.map

package/dist/service.js

@@ -6,13 +6,13 @@ export function systemdUnit(executable, configPath, entrypoint, writablePaths =
         ...(entrypoint === undefined ? [] : [escapeSystemd(entrypoint)])
     ].join(' ');
     const readWritePaths = writablePaths.map((path) => escapeSystemd(resolve(path))).join(' ');
-    return `[Unit]\nDescription=MyAgentRoam Node\nAfter=network-online.target\n\n[Service]\nType=simple\nUser=mar-node\nNoNewPrivileges=true\nPrivateTmp=true\nProtectSystem=strict\n${readWritePaths.length === 0 ? '' : `ReadWritePaths=${readWritePaths}\n`}ExecStart=${command} run --config ${escapeSystemd(configPath)}\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target\n`;
+    return `[Unit]\nDescription=MyAgentRoam Node\nAfter=network-online.target\n\n[Service]\nType=simple\nUser=mar-node\nNoNewPrivileges=true\nPrivateTmp=true\nProtectSystem=strict\n${readWritePaths.length === 0 ? '' : `ReadWritePaths=${readWritePaths}\n`}ExecStart=${command} supervise --config ${escapeSystemd(configPath)}\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target\n`;
 }
 export function windowsServiceDefinition(executable, configPath, entrypoint) {
     return JSON.stringify({
         serviceName: 'MyAgentRoamNode',
         displayName: 'MyAgentRoam Node',
-        binaryPath: `"${executable}"${entrypoint === undefined ? '' : ` "${entrypoint}"`} run --config "${configPath}"`,
+        binaryPath: `"${executable}"${entrypoint === undefined ? '' : ` "${entrypoint}"`} supervise --config "${configPath}"`,
         startType: 'auto',
         account: 'LocalService'
     }, undefined, 2);
@@ -36,4 +36,3 @@ export async function removeServiceDefinition(outputPath) {
 function escapeSystemd(value) {
     return JSON.stringify(value);
 }
-//# sourceMappingURL=service.js.map

package/dist/storage.js

@@ -30,4 +30,3 @@ async function existingParent(path) {
         current = parent;
     }
 }
-//# sourceMappingURL=storage.js.map

package/dist/supervisor.d.ts

@@ -0,0 +1 @@
+export declare function superviseNode(configPath: string, bootstrapEntrypoint: string): Promise<void>;

package/dist/supervisor.js

@@ -0,0 +1,154 @@
+import { spawn } from 'node:child_process';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { loadNodeConfig, nodeDatabasePath } from './config.js';
+import { nodeLog, platformCliInvocation } from './operational.js';
+import { nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
+const UPGRADE_EXIT_CODE = 75;
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+export async function superviseNode(configPath, bootstrapEntrypoint) {
+    const config = await loadNodeConfig(configPath);
+    const dataDirectory = dirname(nodeDatabasePath(config, configPath));
+    const activePath = resolve(dataDirectory, 'node-active-entrypoint');
+    let entrypoint = await readActiveEntrypoint(activePath, bootstrapEntrypoint);
+    for (;;) {
+        const childResult = await runProcess(process.execPath, [entrypoint, 'run', '--config', configPath], true, { ...process.env, MAR_NODE_SUPERVISED: '1' });
+        if (childResult.signalled)
+            return;
+        const code = childResult.code;
+        if (code !== UPGRADE_EXIT_CODE) {
+            if (code === 0)
+                return;
+            nodeLog('node.supervisor.child-exited', { code });
+            await delay(1_000);
+            continue;
+        }
+        const requestPath = nodeUpgradeRequestPath(nodeDatabasePath(config, configPath));
+        let stopping = false;
+        try {
+            const request = JSON.parse(await readFile(requestPath, 'utf8'));
+            const targetVersion = request['targetVersion'];
+            if (request['schemaVersion'] !== 1 ||
+                typeof targetVersion !== 'string' ||
+                !STABLE_VERSION.test(targetVersion))
+                throw new Error('NODE_UPGRADE_REQUEST_INVALID');
+            const prefix = resolve(dataDirectory, 'node-versions', targetVersion);
+            await rm(prefix, { recursive: true, force: true });
+            await mkdir(prefix, { recursive: true, mode: 0o700 });
+            const registry = validatedRegistry(config.upgrade?.registryUrl);
+            const invocation = platformCliInvocation('npm', [
+                'install',
+                '--prefix',
+                prefix,
+                '--ignore-scripts',
+                '--no-audit',
+                '--no-fund',
+                ...(registry === undefined ? [] : ['--registry', registry]),
+                `@myagentroam/node@${targetVersion}`
+            ]);
+            const installResult = await runProcess(invocation.command, invocation.args, false);
+            if (installResult.signalled) {
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
+            }
+            if (installResult.code !== 0)
+                throw new Error('NODE_UPGRADE_INSTALL_FAILED');
+            const rebuild = platformCliInvocation('npm', [
+                'rebuild',
+                '--prefix',
+                prefix,
+                ...(registry === undefined ? [] : ['--registry', registry]),
+                'node-pty'
+            ]);
+            const rebuildResult = await runProcess(rebuild.command, rebuild.args, false);
+            if (rebuildResult.signalled) {
+                stopping = true;
+                throw new Error('NODE_UPGRADE_INSTALL_INTERRUPTED');
+            }
+            if (rebuildResult.code !== 0)
+                throw new Error('NODE_UPGRADE_NATIVE_REBUILD_FAILED');
+            const nextEntrypoint = resolve(prefix, 'node_modules', '@myagentroam', 'node', 'dist', 'main.js');
+            await access(nextEntrypoint);
+            await writeAtomic(activePath, `${nextEntrypoint}\n`);
+            await writeResult(dataDirectory, {
+                state: 'SUCCEEDED',
+                targetVersion,
+                updatedAt: Date.now()
+            });
+            await rm(requestPath, { force: true });
+            entrypoint = nextEntrypoint;
+        }
+        catch (error) {
+            await writeResult(dataDirectory, {
+                state: 'FAILED',
+                errorCode: error instanceof Error ? error.message : 'NODE_UPGRADE_INSTALL_FAILED',
+                updatedAt: Date.now()
+            });
+            await rm(requestPath, { force: true });
+        }
+        if (stopping)
+            return;
+    }
+}
+async function runProcess(command, args, inherit, env = process.env) {
+    return new Promise((resolveProcess) => {
+        const child = spawn(command, args, {
+            windowsHide: true,
+            stdio: inherit ? 'inherit' : 'ignore',
+            env
+        });
+        let settled = false;
+        let signalled = false;
+        const forward = (signal) => {
+            signalled = true;
+            child.kill(signal);
+        };
+        const onSigint = () => forward('SIGINT');
+        const onSigterm = () => forward('SIGTERM');
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            process.off('SIGINT', onSigint);
+            process.off('SIGTERM', onSigterm);
+            resolveProcess({ code, signalled });
+        };
+        process.once('SIGINT', onSigint);
+        process.once('SIGTERM', onSigterm);
+        child.once('error', () => finish(null));
+        child.once('close', finish);
+    });
+}
+async function readActiveEntrypoint(path, fallback) {
+    try {
+        const value = (await readFile(path, 'utf8')).trim();
+        await access(value);
+        return value;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeResult(directory, result) {
+    await writeAtomic(resolve(directory, 'upgrade-result.json'), `${JSON.stringify(result)}\n`);
+}
+async function writeAtomic(path, contents) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, contents, { mode: 0o600 });
+    await rename(temporary, path);
+}
+function validatedRegistry(value) {
+    if (value === undefined)
+        return undefined;
+    const url = new URL(value);
+    if (url.protocol !== 'https:' &&
+        !(url.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(url.hostname)))
+        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
+    if (url.username !== '' || url.password !== '' || url.search !== '' || url.hash !== '')
+        throw new Error('NODE_UPGRADE_REGISTRY_INVALID');
+    return url.toString().replace(/\/$/u, '');
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}

package/dist/terminal.js

@@ -414,4 +414,3 @@ function splitFrameData(value) {
     }
     return chunks;
 }
-//# sourceMappingURL=terminal.js.map

package/dist/util/node-operation-parsers.d.ts

@@ -67,6 +67,7 @@ export declare function boundedConversationItemId(prefix: string, value: string)
 export declare function validUserAuthorization(value: unknown, envelope: NodeEnvelope, operation: string, nodeId: string | undefined, now?: number): boolean;
 export declare function isTerminalRunStatus(status: AgentRunStatus): boolean;
 export declare function validSessionOption(value: unknown): boolean;
+export declare function validSessionEffort(value: unknown): boolean;
 export declare function validSessionTitle(value: unknown): boolean;
 export declare function sessionTitleFromFirstMessage(content: string): string;
 export declare function parseComposerAttachmentUpload(input: Record<string, unknown>): {

package/dist/util/node-operation-parsers.js

@@ -234,6 +234,9 @@ export function validSessionOption(value) {
     return (value === undefined ||
         (typeof value === 'string' && value.trim().length > 0 && value.length <= 120));
 }
+export function validSessionEffort(value) {
+    return value === undefined || (typeof value === 'string' && value.length <= 120);
+}
 export function validSessionTitle(value) {
     return (value === undefined ||
         (typeof value === 'string' && value.trim().length > 0 && value.length <= 160));
@@ -377,4 +380,3 @@ export function isNodeConversationTurn(value) {
         typeof value.sessionId === 'string' &&
         Array.isArray(value.items));
 }
-//# sourceMappingURL=node-operation-parsers.js.map

package/dist/util/runner-native-session-parsers.js

@@ -154,57 +154,119 @@ export function deduplicateDirectSessions(sessions) {
 }
 export function nativeConversationPage(session, history, input, runtimeTurns = [], registerImages = () => []) {
     const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
-    const end = nativePageEnd(input.cursor, session.id, history.items.length);
+    const nativeTurns = nativeTranscriptTurns(history.items);
+    const end = nativePageEnd(input.cursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
-    const turns = history.items.slice(start, end).map((entry, offset) => {
-        const index = start + offset;
-        const time = entry.createdAt ?? index;
-        const turnId = `${session.id}:native:${index}`;
-        const isToolCall = entry.kind === 'tool_call';
-        const isCommand = isToolCall && isClaudeCommandTool(entry.toolName);
-        const userInputQuestions = session.runner === 'claude-code' &&
-            isToolCall &&
-            entry.toolName === 'AskUserQuestion' &&
-            isPlainRecord(entry.input)
-            ? claudeUserInputQuestions(entry.input)
-            : [];
-        const isUserInputRequest = userInputQuestions.length > 0;
-        const clientMessageId = !isToolCall && entry.role === 'USER'
-            ? nativeUserClientMessageId(entry, time, runtimeTurns)
-            : null;
-        // Claude 标签式 Plan Mode：用户正文剥离注入的规划指令标签，
-        // 完整的 <proposed_plan> Agent 文本归一化为计划卡。
-        const entryText = entry.kind === 'message'
-            ? entry.role === 'USER'
-                ? stripClaudePlanTag(entry.text)
-                : entry.text
-            : '';
-        const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
-        const item = {
-            id: `${turnId}:item`,
+    const turns = nativeTurns
+        .slice(start, end)
+        .map((entries, relativeIndex) => {
+        const firstIndex = entries[0]?.index ?? 0;
+        const turnId = `${session.id}:native:${firstIndex}`;
+        const items = entries.map(({ entry, index }) => nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages));
+        const startedAt = items[0]?.startedAt ?? firstIndex;
+        const completedAt = items.at(-1)?.completedAt ?? startedAt;
+        const after = lastNativeItemId(entries);
+        return {
+            id: turnId,
             sessionId: session.id,
-            turnId,
             runId: null,
-            parentItemId: null,
-            sourceSequence: index,
-            revision: 0,
-            kind: isUserInputRequest
-                ? 'user_input_request'
+            userItemId: items.find((item) => item.kind === 'user_message')?.id ?? null,
+            status: 'SUCCEEDED',
+            model: null,
+            effort: null,
+            access: null,
+            ...(after === undefined || session.runner !== 'claude-code'
+                ? {}
+                : {
+                    rewind: {
+                        before: lastNativeItemId(nativeTurns[start + relativeIndex - 1] ?? []) ?? null,
+                        after
+                    }
+                }),
+            items,
+            startedAt,
+            completedAt
+        };
+    });
+    return {
+        turns,
+        nextCursor: start > 0
+            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
+            : null
+    };
+}
+function lastNativeItemId(entries) {
+    return entries.findLast(({ entry }) => entry.nativeId !== undefined)?.entry.nativeId;
+}
+function nativeTranscriptTurns(items) {
+    const turns = [];
+    let current = [];
+    for (const [index, entry] of items.entries()) {
+        if (entry.kind === 'message' && entry.role === 'USER' && current.length > 0) {
+            turns.push(current);
+            current = [];
+        }
+        current.push({ entry, index });
+    }
+    if (current.length > 0)
+        turns.push(current);
+    return turns;
+}
+function nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages) {
+    const time = entry.createdAt ?? index;
+    const isToolCall = entry.kind === 'tool_call';
+    const isUnknown = entry.kind === 'unknown';
+    const isReasoning = entry.kind === 'reasoning_summary';
+    const isCommand = isToolCall && isClaudeCommandTool(entry.toolName);
+    const userInputQuestions = session.runner === 'claude-code' &&
+        isToolCall &&
+        entry.toolName === 'AskUserQuestion' &&
+        isPlainRecord(entry.input)
+        ? claudeUserInputQuestions(entry.input)
+        : [];
+    const isUserInputRequest = userInputQuestions.length > 0;
+    const clientMessageId = entry.kind === 'message' && entry.role === 'USER'
+        ? nativeUserClientMessageId(entry, time, runtimeTurns)
+        : null;
+    // Claude 标签式 Plan Mode：用户正文剥离注入的规划指令标签，
+    // 完整的 <proposed_plan> Agent 文本归一化为计划卡。
+    const entryText = entry.kind === 'message'
+        ? entry.role === 'USER'
+            ? stripClaudePlanTag(entry.text)
+            : entry.text
+        : '';
+    const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
+    const item = {
+        id: `${turnId}:item:${index}`,
+        sessionId: session.id,
+        turnId,
+        runId: null,
+        parentItemId: null,
+        sourceSequence: index,
+        revision: 0,
+        kind: isUserInputRequest
+            ? 'user_input_request'
+            : isReasoning
+                ? 'reasoning_summary'
                 : isToolCall
                     ? isCommand
                         ? 'command_execution'
                         : 'tool_call'
-                    : entry.role === 'USER'
-                        ? 'user_message'
-                        : planText !== undefined
-                            ? 'plan'
-                            : 'assistant_message',
-            status: 'COMPLETED',
-            payload: isUserInputRequest
-                ? {
-                    requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${index}`}`,
-                    questions: userInputQuestions
-                }
+                    : isUnknown
+                        ? 'unknown'
+                        : entry.kind === 'message' && entry.role === 'USER'
+                            ? 'user_message'
+                            : planText !== undefined
+                                ? 'plan'
+                                : 'assistant_message',
+        status: 'COMPLETED',
+        payload: isUserInputRequest
+            ? {
+                requestId: `native:${entry.kind === 'tool_call' ? entry.toolUseId : `item-${index}`}`,
+                questions: userInputQuestions
+            }
+            : isReasoning
+                ? { sections: entry.sections }
                 : isToolCall
                     ? isCommand
                         ? {
@@ -229,34 +291,17 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
                                 ? {}
                                 : { attachments: registerImages(entry.imageAttachments) })
                         }
-                    : entry.role === 'USER'
-                        ? { clientMessageId, text: entryText, contexts: [], delivery: 'ACCEPTED' }
-                        : planText !== undefined
-                            ? { explanation: compactRunnerText(planText, 20_000), steps: [] }
-                            : { text: entryText, format: 'markdown', source: 'native-file' },
-            startedAt: time,
-            completedAt: time
-        };
-        return {
-            id: turnId,
-            sessionId: session.id,
-            runId: null,
-            userItemId: !isToolCall && entry.role === 'USER' ? item.id : null,
-            status: 'SUCCEEDED',
-            model: null,
-            effort: null,
-            access: null,
-            items: [item],
-            startedAt: time,
-            completedAt: time
-        };
-    });
-    return {
-        turns,
-        nextCursor: start > 0
-            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
-            : null
+                    : isUnknown
+                        ? { sourceEventType: entry.sourceEventType, label: entry.label }
+                        : entry.kind === 'message' && entry.role === 'USER'
+                            ? { clientMessageId, text: entryText, contexts: [], delivery: 'ACCEPTED' }
+                            : planText !== undefined
+                                ? { explanation: compactRunnerText(planText, 20_000), steps: [] }
+                                : { text: entryText, format: 'markdown', source: 'native-file' },
+        startedAt: time,
+        completedAt: time
     };
+    return item;
 }
 /**
  * Claude JSONL 不保存浏览器请求 ID。Node 进程仍存活时，以正文和生成时刻
@@ -326,7 +371,7 @@ export function claudeUserInputQuestions(value) {
             prompt: compactRunnerText(raw.question, 5_000),
             input: options.length === 0 ? 'SHORT_TEXT' : multiSelect ? 'MULTI_SELECT' : 'SINGLE_SELECT',
             options,
-            allowOther: options.length === 0,
+            allowOther: true,
             multiSelect
         };
     });
@@ -334,4 +379,3 @@ export function claudeUserInputQuestions(value) {
         ? []
         : questions;
 }
-//# sourceMappingURL=runner-native-session-parsers.js.map

package/dist/util/secret-environment.js

@@ -23,4 +23,3 @@ export function parseSecretEnvironment(value) {
     }
     return environment;
 }
-//# sourceMappingURL=secret-environment.js.map

package/dist/workspace.d.ts

@@ -41,6 +41,7 @@ export interface WorkspaceDirectoryListing {
     readonly entries: readonly WorkspaceDirectoryEntry[];
     readonly truncated: boolean;
 }
+export declare function createWorkspaceDirectory(parentPath: string, directoryName: string, allowedRoots: readonly string[]): Promise<string>;
 /** A per-workspace, process-local index for the Quick Open file picker. */
 export declare class WorkspaceFileIndex {
     private readonly workspaceRoot;
@@ -61,8 +62,12 @@ export declare class WorkspaceFileIndex {
     });
     /** Starts/renews the lightweight index observer without exposing file data. */
     observe(): Promise<void>;
+    contentCandidates(): Promise<{
+        readonly entries: readonly WorkspaceFileEntry[];
+        readonly truncated: boolean;
+    }>;
     dispose(): void;
-    search(query: string, cursor?: string, limit?: number): Promise<WorkspaceFileSearchPage>;
+    search(query: string, cursor?: string, limit?: number, includeDirectories?: boolean): Promise<WorkspaceFileSearchPage>;
     private ensureLoaded;
     private touch;
     private rebuild;
@@ -77,6 +82,24 @@ export declare class WorkspaceFileIndex {
  */
 export declare function listWorkspaceDirectories(requestedPath: string | undefined, allowedRoots: readonly string[], homePath?: string): Promise<WorkspaceDirectoryListing>;
 export declare function listWorkspaceFiles(workspaceRoot: string, requestedPath?: string, cursor?: string, limit?: number): Promise<WorkspaceFilePage>;
+export type WorkspaceFileMutation = {
+    readonly action: 'CREATE_FILE';
+    readonly path: string;
+} | {
+    readonly action: 'CREATE_DIRECTORY';
+    readonly path: string;
+} | {
+    readonly action: 'MOVE';
+    readonly path: string;
+    readonly destination: string;
+} | {
+    readonly action: 'DELETE';
+    readonly path: string;
+};
+export declare function mutateWorkspaceFile(workspaceRoot: string, mutation: WorkspaceFileMutation): Promise<{
+    readonly path?: string;
+    readonly deleted?: true;
+}>;
 /** Validates an upload destination without following an existing target symlink. */
 export declare function preflightWorkspaceUpload(workspaceRoot: string, requestedDirectory: string, name: string): Promise<WorkspaceUploadTarget>;
 export declare function workspaceUploadTemporaryName(uploadId: string): string;
@@ -98,7 +121,7 @@ export declare function readAllowedTextFile(requestedPath: string, allowedRoots:
     readonly nextOffset: number | null;
 }>;
 /** Searches file names only, so an exploratory request cannot exfiltrate file contents. */
-export declare function searchWorkspaceFiles(workspaceRoot: string, query: string, cursor?: string, limit?: number): Promise<WorkspaceFileSearchPage>;
+export declare function searchWorkspaceFiles(workspaceRoot: string, query: string, cursor?: string, limit?: number, includeDirectories?: boolean): Promise<WorkspaceFileSearchPage>;
 export declare function normalizeWorkspacePath(input: string, platform?: NodeJS.Platform): string;
 export declare function isWithinAllowedRoot(target: string, roots: readonly string[], platform?: NodeJS.Platform): boolean;
 /** Resolving both candidate and roots rejects Linux symlinks which point outside a root. */
@@ -128,6 +151,35 @@ export declare function readCurrentChangesSummary(workspacePath: string): Promis
 }>;
 export declare function listInitializedSubmodulePaths(workspacePath: string): Promise<readonly string[]>;
 export declare function resolveGitRepository(workspacePath: string, repositoryPath: string): Promise<string>;
+export interface GitHistoryRefEntry {
+    readonly name: string;
+    readonly displayName: string;
+    readonly kind: 'LOCAL' | 'REMOTE';
+    readonly hash: string;
+    readonly current: boolean;
+}
+export declare function listGitHistoryRefs(repository: string): Promise<readonly GitHistoryRefEntry[]>;
+export declare function readGitHistory(repository: string, input: {
+    readonly refs?: readonly string[];
+    readonly cursor?: string;
+    readonly limit?: number;
+}): Promise<{
+    readonly commits: readonly object[];
+    readonly nextCursor: string | null;
+}>;
+export declare function readGitHistoryFiles(repository: string, commit: string, refs?: readonly string[]): Promise<readonly {
+    path: string;
+    previousPath?: string;
+    change: ReturnType<typeof gitChange>;
+}[]>;
+export declare function readGitHistoryFileDiff(repository: string, commit: string, requestedPath: string, refs?: readonly string[], requestedPreviousPath?: string): Promise<{
+    readonly binary: boolean;
+    readonly text?: string;
+    readonly summary?: string;
+    readonly truncated: boolean;
+    readonly beforePreview?: BinaryDiffPreview;
+    readonly afterPreview?: BinaryDiffPreview;
+}>;
 export declare function readCurrentChanges(workspacePath: string): Promise<readonly {
     readonly path: string;
     readonly state: 'STAGED' | 'UNSTAGED' | 'UNTRACKED';
@@ -140,12 +192,20 @@ export declare function readCurrentChangeDiff(workspacePath: string, requestedPa
     readonly truncated: boolean;
     readonly afterText?: string;
     readonly afterTruncated?: boolean;
+    readonly beforePreview?: BinaryDiffPreview;
+    readonly afterPreview?: BinaryDiffPreview;
 }>;
 /** Current Changes must not expose an external link. */
 export declare function isWorkspaceChangeVisible(workspacePath: string, requestedPath: string): Promise<boolean>;
+interface BinaryDiffPreview {
+    readonly contentBase64?: string;
+    readonly truncated: boolean;
+}
 export declare function restoreCurrentChange(workspacePath: string, requestedPath: string, state: 'STAGED' | 'UNSTAGED' | 'UNTRACKED'): Promise<void>;
+declare function gitChange(status: string): 'ADDED' | 'MODIFIED' | 'DELETED' | 'RENAMED' | 'COPIED' | 'TYPE_CHANGED';
 export declare class GitCommandError extends Error {
     readonly code: number;
     readonly stderr: string;
     constructor(code: number, stderr: string);
 }
+export {};