@myagentroam/node 0.9.96 → 0.9.98

package/dist/service/code-navigation/navigation-resolution-registry.js

@@ -0,0 +1,36 @@
+import { cFamilyNavigationResolutionDefinition, cNavigationResolutionDefinition, cppNavigationResolutionDefinition, objectiveCNavigationResolutionDefinition, objectiveCppNavigationResolutionDefinition } from './c-family-path-specifier-resolver.js';
+import { csharpNavigationResolutionDefinition } from './csharp-path-specifier-resolver.js';
+import { ecmascriptNavigationResolutionDefinition } from './ecmascript-path-specifier-resolver.js';
+import { goNavigationResolutionDefinition } from './go-path-specifier-resolver.js';
+import { jvmNavigationResolutionDefinition } from './jvm-path-specifier-resolver.js';
+import { markdownNavigationResolutionDefinition } from './markdown-path-specifier-resolver.js';
+import { pythonNavigationResolutionDefinition } from './python-path-specifier-resolver.js';
+import { rustNavigationResolutionDefinition } from './rust-path-specifier-resolver.js';
+import { cssNavigationResolutionDefinition, htmlNavigationResolutionDefinition, lessNavigationResolutionDefinition, sassNavigationResolutionDefinition, scssNavigationResolutionDefinition, vueNavigationResolutionDefinition } from './stylesheet-path-specifier-resolver.js';
+const definitionsByLanguage = {
+    css: cssNavigationResolutionDefinition,
+    ecmascript: ecmascriptNavigationResolutionDefinition,
+    go: goNavigationResolutionDefinition,
+    html: htmlNavigationResolutionDefinition,
+    jvm: jvmNavigationResolutionDefinition,
+    csharp: csharpNavigationResolutionDefinition,
+    less: lessNavigationResolutionDefinition,
+    markdown: markdownNavigationResolutionDefinition,
+    python: pythonNavigationResolutionDefinition,
+    sass: sassNavigationResolutionDefinition,
+    scss: scssNavigationResolutionDefinition,
+    c: cNavigationResolutionDefinition,
+    cpp: cppNavigationResolutionDefinition,
+    'objective-c': objectiveCNavigationResolutionDefinition,
+    'objective-cpp': objectiveCppNavigationResolutionDefinition,
+    'c-family': cFamilyNavigationResolutionDefinition,
+    rust: rustNavigationResolutionDefinition,
+    vue: vueNavigationResolutionDefinition
+};
+export function navigationResolutionDefinitions() {
+    return Object.values(definitionsByLanguage);
+}
+export function pathSpecifierResolver(languageId, specifier) {
+    const definition = definitionsByLanguage[languageId];
+    return definition?.resolver.accepts(specifier) === true ? definition.resolver : undefined;
+}

package/dist/service/code-navigation/navigation-target-validator.js

@@ -0,0 +1,121 @@
+import { lstat, open, readFile, realpath } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+const MAX_SOURCE_BYTES = 4 * 1024 * 1024;
+const READ_BLOCK_BYTES = 4096;
+const MAX_TARGET_PREVIEW_CHARACTERS = 512;
+export function sourceFileFingerprint(size, modifiedAt) {
+    return `${size}:${modifiedAt ?? -1}`;
+}
+export async function validateSymbolTarget(root, target, symbol, expectedFingerprint) {
+    const actual = await validatedFile(root, target.path, expectedFingerprint);
+    if (actual === undefined)
+        return undefined;
+    const line = await lineAt(actual, target.line);
+    return line !== undefined && containsSymbol(line, symbol) ? targetPreview(line) : undefined;
+}
+export async function validatePathTarget(root, path, expectedFingerprint, anchor, anchorLine) {
+    const actual = await validatedFile(root, path, expectedFingerprint);
+    if (actual === undefined)
+        return undefined;
+    const line = anchor === undefined || anchorLine === undefined
+        ? 1
+        : anchorLine(await readFile(actual, 'utf8').catch(() => ''), anchor);
+    if (line === undefined)
+        return undefined;
+    const preview = await lineAt(actual, line);
+    return preview === undefined ? undefined : { line, preview };
+}
+async function validatedFile(root, path, expectedFingerprint) {
+    const requested = resolve(root, ...path.split('/'));
+    const requestedMetadata = await lstat(requested).catch(() => undefined);
+    if (requestedMetadata === undefined ||
+        !requestedMetadata.isFile() ||
+        requestedMetadata.isSymbolicLink() ||
+        requestedMetadata.size > MAX_SOURCE_BYTES)
+        return undefined;
+    const actual = await realpath(requested).catch(() => undefined);
+    if (actual === undefined ||
+        relative(root, actual)
+            .split(sep)
+            .some((part) => part === '..'))
+        return undefined;
+    const metadata = await lstat(actual).catch(() => undefined);
+    if (metadata === undefined ||
+        !metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.size > MAX_SOURCE_BYTES ||
+        (expectedFingerprint !== undefined &&
+            sourceFileFingerprint(metadata.size, metadata.mtimeMs) !== expectedFingerprint))
+        return undefined;
+    return actual;
+}
+export function targetPreview(line) {
+    if (line.length <= MAX_TARGET_PREVIEW_CHARACTERS)
+        return line;
+    const contentLimit = MAX_TARGET_PREVIEW_CHARACTERS - 1;
+    const end = line.charCodeAt(contentLimit - 1);
+    const safeEnd = end >= 0xd800 && end <= 0xdbff ? contentLimit - 1 : contentLimit;
+    return `${line.slice(0, safeEnd)}…`;
+}
+async function lineAt(path, targetLine) {
+    const handle = await open(path, 'r');
+    try {
+        let offset = 0;
+        let line = 1;
+        let pending = Buffer.alloc(0);
+        while (offset < MAX_SOURCE_BYTES) {
+            const chunk = Buffer.alloc(READ_BLOCK_BYTES);
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, offset);
+            if (bytesRead === 0)
+                return line === targetLine ? pending.toString('utf8') : undefined;
+            offset += bytesRead;
+            let content = pending.length === 0
+                ? chunk.subarray(0, bytesRead)
+                : Buffer.concat([pending, chunk.subarray(0, bytesRead)]);
+            let newline;
+            while ((newline = content.indexOf(0x0a)) >= 0) {
+                if (line === targetLine)
+                    return content.subarray(0, newline).toString('utf8');
+                line += 1;
+                content = content.subarray(newline + 1);
+            }
+            pending = content;
+        }
+        return line === targetLine ? pending.toString('utf8') : undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function containsSymbol(line, symbol) {
+    const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    const optionalScssPrefix = symbol.startsWith('$') ? '' : '\\$?';
+    return new RegExp(`(?:^|[^\\p{L}\\p{N}_$])${optionalScssPrefix}${escaped}(?![\\p{L}\\p{N}_$])`, 'u').test(line);
+}
+export function compareTargets(left, right, currentPath) {
+    const leftScore = targetScore(left, currentPath);
+    const rightScore = targetScore(right, currentPath);
+    return (rightScore - leftScore ||
+        left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        (left.kind ?? '').localeCompare(right.kind ?? ''));
+}
+function targetScore(target, currentPath) {
+    if (target.path === currentPath)
+        return 100;
+    const currentDirectory = currentPath.includes('/')
+        ? currentPath.slice(0, currentPath.lastIndexOf('/'))
+        : '';
+    const targetDirectory = target.path.includes('/')
+        ? target.path.slice(0, target.path.lastIndexOf('/'))
+        : '';
+    return commonPathSegments(currentDirectory, targetDirectory);
+}
+function commonPathSegments(left, right) {
+    const leftParts = left === '' ? [] : left.split('/');
+    const rightParts = right === '' ? [] : right.split('/');
+    let count = 0;
+    while (count < leftParts.length && leftParts[count] === rightParts[count])
+        count += 1;
+    return count;
+}

package/dist/service/code-navigation/path-specifier-resolver.js

@@ -0,0 +1,6 @@
+export function matchesPathSuffix(path, suffix) {
+    return path === suffix || path.endsWith(`/${suffix}`);
+}
+export function shortestPathScore(path) {
+    return path.length;
+}

package/dist/service/code-navigation/python-path-specifier-resolver.js

@@ -0,0 +1,41 @@
+import { matchesPathSuffix, shortestPathScore } from './path-specifier-resolver.js';
+import { posix } from 'node:path';
+function accepts(value) {
+    return (/^[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*$/u.test(value) ||
+        /^\.+(?:[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*)?$/u.test(value));
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).some((candidate) => matchesPathSuffix(path, candidate));
+}
+function directCandidates(currentPath, specifier) {
+    return specifier.startsWith('.') ? candidates(currentPath, specifier) : [];
+}
+function candidates(currentPath, specifier) {
+    const packagePath = relativePackagePath(currentPath, specifier);
+    if (packagePath === undefined)
+        return [];
+    return packagePath === '.'
+        ? ['__init__.py']
+        : [`${packagePath}.py`, `${packagePath}.pyw`, `${packagePath}/__init__.py`];
+}
+function relativePackagePath(currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return specifier.replaceAll('.', '/');
+    const levels = specifier.match(/^\.+/u)?.[0].length ?? 0;
+    const module = specifier.slice(levels).replaceAll('.', '/');
+    const base = posix.normalize(posix.join(posix.dirname(currentPath), ...Array.from({ length: levels - 1 }, () => '..')));
+    if (base === '..' || base.startsWith('../'))
+        return undefined;
+    return module.length === 0 ? base : posix.join(base, module);
+}
+export const pythonPathSpecifierResolver = {
+    id: 'python.path-specifier',
+    accepts,
+    directCandidates,
+    matches,
+    score: shortestPathScore
+};
+export const pythonNavigationResolutionDefinition = {
+    languageId: 'python',
+    resolver: pythonPathSpecifierResolver
+};

package/dist/service/code-navigation/rust-path-specifier-resolver.js

@@ -0,0 +1,31 @@
+import { posix } from 'node:path';
+function accepts(value) {
+    return (/^[A-Za-z_][A-Za-z0-9_]*$/u.test(value) || /^(?:\.\.?\/)?[A-Za-z0-9_./-]+\.rs$/u.test(value));
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).includes(path);
+}
+function score(path, currentPath, specifier) {
+    const index = candidates(currentPath, specifier).indexOf(path);
+    return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+function candidates(currentPath, specifier) {
+    const directory = posix.dirname(currentPath);
+    if (specifier.endsWith('.rs')) {
+        const resolved = posix.normalize(posix.join(directory, specifier));
+        return resolved.startsWith('../') || resolved === '..' ? [] : [resolved];
+    }
+    const base = directory === '.' ? specifier : `${directory}/${specifier}`;
+    return [`${base}.rs`, `${base}/mod.rs`];
+}
+export const rustPathSpecifierResolver = {
+    id: 'rust.path-specifier',
+    accepts,
+    directCandidates: candidates,
+    matches,
+    score
+};
+export const rustNavigationResolutionDefinition = {
+    languageId: 'rust',
+    resolver: rustPathSpecifierResolver
+};

package/dist/service/code-navigation/stylesheet-path-specifier-resolver.js

@@ -0,0 +1,55 @@
+import { posix } from 'node:path';
+function accepts(value) {
+    return /^(?:\.\.?\/)?[A-Za-z0-9_./$+@ -]+$/u.test(value);
+}
+function createResolver(languageId, extensions, partials = false) {
+    const candidates = (currentPath, specifier) => pathCandidates(currentPath, specifier, extensions, partials);
+    return {
+        id: `${languageId}.path-specifier`,
+        accepts,
+        directCandidates: candidates,
+        matches: (path, currentPath, specifier) => candidates(currentPath, specifier).includes(path),
+        score: (path, currentPath, specifier) => {
+            const index = candidates(currentPath, specifier).indexOf(path);
+            return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+        }
+    };
+}
+function pathCandidates(currentPath, specifier, extensions, partials) {
+    const resolved = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (resolved === '..' || resolved.startsWith('../'))
+        return [];
+    const path = resolved.replace(/^\.\//u, '');
+    if (path.slice(path.lastIndexOf('/') + 1).includes('.'))
+        return [path];
+    const base = extensions.flatMap((extension) => [
+        `${path}${extension}`,
+        `${path}/index${extension}`
+    ]);
+    if (!partials)
+        return base;
+    const directory = posix.dirname(path);
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return [...base, ...extensions.map((extension) => posix.join(directory, `_${name}${extension}`))];
+}
+function definition(languageId, extensions, partials = false) {
+    return { languageId, resolver: createResolver(languageId, extensions, partials) };
+}
+export const cssNavigationResolutionDefinition = definition('css', ['.css']);
+export const scssNavigationResolutionDefinition = definition('scss', ['.scss', '.css'], true);
+export const sassNavigationResolutionDefinition = definition('sass', ['.sass', '.scss', '.css'], true);
+export const lessNavigationResolutionDefinition = definition('less', ['.less', '.css']);
+export const htmlNavigationResolutionDefinition = definition('html', [
+    '.html',
+    '.htm',
+    '.css',
+    '.js'
+]);
+export const vueNavigationResolutionDefinition = definition('vue', [
+    '.vue',
+    '.html',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less'
+]);

package/dist/service/conversation-history-service.js

@@ -317,7 +317,7 @@ export class ConversationHistoryService {
     async refreshExternalActivity(session) {
         const runner = this.options.runners.require(session.runner);
         if (!runner.available(this.options.capabilities())) {
-            this.options.setExternalActivity(session.id, 'UNAVAILABLE');
+            this.options.setExternalActivity(session.id, 'IDLE');
             return;
         }
         const activity = await runner.readExternalActivity(session);

package/dist/service/external-session-resume-service.js

@@ -31,6 +31,7 @@ export class ExternalSessionResumeService {
             return this.options.ensureConfiguration(prior);
         const runner = this.options.runners.product(external.runner);
         if (runner === undefined) {
+            this.options.state.externalActivity.set(external.id, 'IDLE');
             this.setFailure(external.id, 'RUNNER_UNAVAILABLE');
             return undefined;
         }
@@ -78,6 +79,8 @@ export class ExternalSessionResumeService {
         }
         if (result.activity !== undefined)
             this.options.state.externalActivity.set(external.id, result.activity);
+        else if (result.failureCode === 'RUNNER_UNAVAILABLE')
+            this.options.state.externalActivity.set(external.id, 'IDLE');
         if (result.session !== undefined) {
             this.options.state.resumedByDirectId.set(external.id, result.session.id);
             return result.session;
@@ -102,32 +105,12 @@ export class ExternalSessionResumeService {
         const resumed = await this.resume(current);
         if (resumed !== undefined)
             return resumed;
-        if (this.options.state.externalActivity.get(current.id) === 'EXTERNAL_ACTIVE')
+        if (this.options.state.externalActivity.get(current.id) === 'BUSY')
             throw new Error('EXTERNAL_SESSION_ACTIVE');
         throw new Error(this.options.state.messageResumeFailures.get(current.id) ?? this.failure(current.id).code);
     }
     async acceptForMessage(sessionId) {
-        const resumedId = this.options.state.resumedByDirectId.get(sessionId);
-        const current = this.options.runtime.getAgentSession(resumedId ?? sessionId) ??
-            (await this.options.resolve(sessionId));
-        if (current === undefined)
-            throw new Error('SESSION_NOT_FOUND');
-        if (current.nativeControl !== 'EXTERNAL')
-            return { session: current, ready: Promise.resolve(current), deferred: false };
-        const staged = this.options.projectionFor(current) ?? this.options.stage(current);
-        const ready = this.resume(current).then((session) => {
-            if (session !== undefined)
-                return session;
-            if (this.options.state.externalActivity.get(current.id) === 'EXTERNAL_ACTIVE')
-                throw new Error('EXTERNAL_SESSION_ACTIVE');
-            throw new Error(this.options.state.messageResumeFailures.get(current.id) ?? this.failure(current.id).code);
-        });
-        return { session: staged, ready, deferred: true };
-    }
-    delivery(session) {
-        return session.nativeControl === 'EXTERNAL' && session.externalSessionId !== null
-            ? 'RESUMABLE'
-            : 'REJECTED';
+        return { session: await this.resolveForMessage(sessionId) };
     }
     clearFailure(sessionId) {
         const timer = this.options.state.failureTimers.get(sessionId);

package/dist/service/node-control-message-service.js

@@ -68,7 +68,7 @@ export class NodeControlMessageService {
             this.cancelRun(envelope);
             return;
         }
-        if (envelope.type === 'session.resume' || envelope.type === 'lease.reconcile') {
+        if (envelope.type === 'lease.reconcile') {
             this.options.send('ack', { type: envelope.type }, envelope.id);
             return;
         }

package/dist/service/node-upgrade-coordinator.js

@@ -62,7 +62,6 @@ export class NodeUpgradeCoordinator {
     blocks(operation) {
         return (this.pending() &&
             (operation === 'session.start' ||
-                operation === 'session.resume' ||
                 operation === 'session.message' ||
                 operation === 'session.command.execute' ||
                 operation === 'runner.command.execute' ||

package/dist/service/session-catalog-service.js

@@ -11,7 +11,6 @@ export class SessionCatalogService {
     operations() {
         return {
             'session.list': (data) => this.list(record(data)),
-            'session.resume': (data) => this.resume(record(data)),
             'session.remove': (data) => this.enqueueMutation(() => this.remove(record(data))),
             'workspace.sessions.cleanup': (data) => this.enqueueMutation(() => this.cleanupWorkspaceSessions(record(data))),
             'session.rewind': (data) => this.enqueueMutation(() => this.rewind(record(data))),
@@ -100,30 +99,6 @@ export class SessionCatalogService {
             }));
         }
     }
-    async resume(input) {
-        if (typeof input.sessionId !== 'string')
-            throw new Error('SESSION_INVALID');
-        const value = this.options.runtime.getAgentSession(input.sessionId) ??
-            (await this.options.projection.resolve(input.sessionId));
-        if (value === undefined)
-            throw new Error('SESSION_NOT_FOUND');
-        if (value.nativeControl !== 'EXTERNAL')
-            return {
-                session: this.options.present(value),
-                delivery: this.options.resume.delivery(value)
-            };
-        const resumed = await this.options.resume.resume(value);
-        const failure = resumed === undefined ? this.options.resume.failure(value.id) : undefined;
-        return {
-            session: this.options.present(resumed ?? value),
-            delivery: resumed === undefined ? 'REJECTED' : 'RESUMABLE',
-            ...(resumed === undefined
-                ? {
-                    reasonCode: failure?.code ?? 'SESSION_RESUME_REJECTED'
-                }
-                : {})
-        };
-    }
     enqueueMutation(operation) {
         const result = this.rewindQueue.then(operation);
         this.rewindQueue = result.then(() => undefined, () => undefined);
@@ -263,7 +238,7 @@ export class SessionCatalogService {
                 this.options.runtime
                     .listRunsForSession(session.id)
                     .some((run) => !isTerminalRunStatus(run.status)) ||
-                this.options.externalActivity(session.id) === 'EXTERNAL_ACTIVE') {
+                this.options.externalActivity(session.id) === 'BUSY') {
                 skipped += 1;
                 continue;
             }
@@ -317,7 +292,7 @@ export class SessionCatalogService {
                 throw new Error('SESSION_ACTIVE');
             if (session.nativeControl === 'EXTERNAL') {
                 await this.options.refreshActivity(session);
-                if (this.options.externalActivity(session.id) === 'EXTERNAL_ACTIVE')
+                if (this.options.externalActivity(session.id) === 'BUSY')
                     throw new Error('SESSION_ACTIVE');
             }
             if (requireCleanupSafety) {

package/dist/service/session-command-service.js

@@ -39,9 +39,9 @@ export class SessionCommandService {
             (await this.options.projection.resolveCurrent(input.sessionId));
         if (resolved === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        const session = resolved.nativeControl === 'EXTERNAL' ? await this.options.resume.resume(resolved) : resolved;
-        if (session === undefined)
-            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        if (resolved.nativeControl === 'EXTERNAL')
+            throw new Error('SESSION_ACTIVATION_REQUIRED');
+        const session = resolved;
         const command = this.options
             .profiles()
             .find((profile) => profile.runner === session.runner)

package/dist/service/session-message-service.js

@@ -88,7 +88,7 @@ export class SessionMessageService {
         const publicContent = missionMessage?.activated === true ? 'Mission Start' : content;
         const intent = missionMessage === undefined ? requestedIntent : 'REPLACE_CURRENT';
         const operation = (async () => {
-            const acceptedSession = accepted.deferred ? accepted.session : await accepted.ready;
+            const acceptedSession = accepted.session;
             const session = this.options.runtime.getAgentSession(acceptedSession.id) ?? acceptedSession;
             const runId = randomUUID();
             const queueBeforeCreate = this.options.runtime.sessionQueue(session.id);
@@ -108,16 +108,12 @@ export class SessionMessageService {
             const sessionForPresentation = input.__mission === true
                 ? session
                 : this.options.runtime.setTemporaryTitleIfMissing(session.id, sessionTitleFromFirstMessage(content));
-            const deferPreparation = accepted.deferred && attachmentIds.length === 0 && inlineAttachments.length === 0;
             this.options.emitSession(sessionForPresentation);
             if (created.queueItem === undefined)
                 this.options.coordinator.publishCurrentTurn(created.run.id);
             const prepare = async () => {
                 try {
-                    const readySession = await accepted.ready;
-                    const currentSession = this.options.runtime.getAgentSession(readySession.id) ?? readySession;
-                    if (deferPreparation)
-                        this.options.emitSession(currentSession);
+                    const currentSession = this.options.runtime.getAgentSession(session.id) ?? session;
                     const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
                     const attachments = attachmentIds.length === 0
                         ? inlineAttachments
@@ -190,15 +186,7 @@ export class SessionMessageService {
                     throw error;
                 }
             };
-            if (deferPreparation)
-                void prepare().catch(() => undefined);
-            const delivery = deferPreparation
-                ? created.queueItem === undefined
-                    ? 'STARTED'
-                    : intent === 'REPLACE_CURRENT'
-                        ? 'RESTARTING'
-                        : 'QUEUED'
-                : await prepare();
+            const delivery = await prepare();
             return {
                 session: this.options.present(sessionForPresentation),
                 run: created.run,

package/dist/service/session-presentation-service.js

@@ -14,7 +14,6 @@ export class SessionPresentationService {
             .require(session.runner)
             .presentSession(session, this.options.capabilities(), {
             managedActive: this.options.hasManagedActiveRun(session),
-            externalActivity: this.options.externalActivity(session.id),
             commandStates: this.options.commands.list(session.id)
         });
         return {