engineering-memory 1.11.14 → 1.11.16

package/runtime/dist/src/runtime/worktree-editor.js

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { constants } from 'node:fs';
+import { access, open, realpath, stat } from 'node:fs/promises';
+import { delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
+export var WorktreeEditorStatus;
+(function (WorktreeEditorStatus) {
+    WorktreeEditorStatus["Requested"] = "requested";
+    WorktreeEditorStatus["Unavailable"] = "unavailable";
+    WorktreeEditorStatus["Failed"] = "failed";
+    WorktreeEditorStatus["Skipped"] = "skipped";
+})(WorktreeEditorStatus || (WorktreeEditorStatus = {}));
+export async function openWorktreeInEditor(repoRoot) {
+    if (!['win32', 'darwin', 'linux'].includes(process.platform) ||
+        (process.env.CI && !/^(false|0)$/i.test(process.env.CI)) ||
+        process.env.SSH_CONNECTION ||
+        process.env.SSH_CLIENT ||
+        process.env.SSH_TTY ||
+        process.env.VSCODE_AGENT_FOLDER ||
+        process.env.VSCODE_REMOTE_NAME ||
+        process.env.WSL_DISTRO_NAME ||
+        process.env.CODESPACES === 'true' ||
+        process.env.SESSIONNAME?.toLowerCase() === 'services' ||
+        (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'A local desktop session is not available.',
+        };
+    }
+    let folder;
+    try {
+        if (!repoRoot.trim())
+            throw new Error();
+        folder = await realpath(resolve(repoRoot));
+        if (!(await stat(folder)).isDirectory())
+            throw new Error();
+    }
+    catch {
+        return {
+            status: WorktreeEditorStatus.Failed,
+            detail: 'The worktree folder is not accessible.',
+        };
+    }
+    const command = await findEditor().catch(() => null);
+    if (!command) {
+        return {
+            status: WorktreeEditorStatus.Unavailable,
+            detail: 'An installed local VS Code CLI was not found.',
+        };
+    }
+    if (/[\\/](?:\.vscode-server(?:-insiders)?|remote-cli)[\\/]/i.test(command.executable)) {
+        return {
+            status: WorktreeEditorStatus.Skipped,
+            detail: 'The available VS Code CLI belongs to a remote session.',
+        };
+    }
+    const env = { ...process.env };
+    delete env.VSCODE_DEV;
+    if (process.platform === 'win32')
+        env.ELECTRON_RUN_AS_NODE = '1';
+    try {
+        return await new Promise((resolveResult) => {
+            const child = spawn(command.executable, [...command.args, '--new-window', folder], {
+                cwd: folder,
+                env,
+                shell: false,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let settled = false;
+            let outputBytes = 0;
+            const timer = setTimeout(() => stop('The VS Code request timed out; window state is unknown.'), 10_000);
+            const finish = (status, detail) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.stdout.destroy();
+                child.stderr.destroy();
+                child.unref();
+                resolveResult({ status, detail });
+            };
+            const stop = (detail) => {
+                if (settled)
+                    return;
+                try {
+                    child.kill('SIGKILL');
+                }
+                finally {
+                    finish(WorktreeEditorStatus.Failed, detail);
+                }
+            };
+            const discardOutput = (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > 65_536) {
+                    stop('The VS Code CLI exceeded the output limit; window state is unknown.');
+                }
+            };
+            child.stdout.on('data', discardOutput);
+            child.stderr.on('data', discardOutput);
+            child.once('error', () => finish(WorktreeEditorStatus.Failed, 'The VS Code CLI could not start.'));
+            child.once('close', (code) => finish(code === 0 ? WorktreeEditorStatus.Requested : WorktreeEditorStatus.Failed, code === 0
+                ? 'VS Code launch requested; window state was not verified.'
+                : 'The VS Code CLI failed; window state is unknown.'));
+        });
+    }
+    catch {
+        return { status: WorktreeEditorStatus.Failed, detail: 'The VS Code CLI could not start.' };
+    }
+}
+async function findEditor() {
+    const directories = (process.env.PATH ?? '')
+        .split(delimiter)
+        .map((directory) => directory.replace(/^"(.+)"$/, '$1'))
+        .filter(isAbsolute)
+        .slice(0, 128);
+    if (process.platform === 'win32') {
+        for (const root of [
+            process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'Programs'),
+            process.env.ProgramFiles,
+            process.env['ProgramFiles(x86)'],
+        ]) {
+            if (root && isAbsolute(root))
+                directories.push(join(root, 'Microsoft VS Code', 'bin'));
+        }
+    }
+    for (const directory of new Set(directories)) {
+        if (process.platform === 'win32') {
+            const command = await windowsEditor(directory);
+            if (command)
+                return command;
+        }
+        else {
+            const executable = join(directory, 'code');
+            if (await executableFile(executable)) {
+                return { executable: await realpath(executable), args: [] };
+            }
+        }
+    }
+    return null;
+}
+async function windowsEditor(bin) {
+    let handle;
+    try {
+        const launcher = await realpath(join(bin, 'code.cmd'));
+        handle = await open(launcher, 'r');
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > 16_384)
+            return null;
+        const bytes = Buffer.alloc(16_385);
+        const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+        if (bytesRead > 16_384)
+            return null;
+        const match = bytes
+            .subarray(0, bytesRead)
+            .toString('utf8')
+            .match(/^[ \t]*"%~dp0\.\.\\Code\.exe"[ \t]+"%~dp0\.\.\\((?:[a-f0-9]{7,40}\\)?resources\\app\\out\\cli\.js)"[ \t]+%\*[ \t]*\r?$/im);
+        if (!match)
+            return null;
+        const installation = resolve(dirname(launcher), '..');
+        const executable = join(installation, 'Code.exe');
+        const cli = join(installation, match[1]);
+        if (!(await executableFile(executable)) || !(await stat(cli)).isFile())
+            return null;
+        return { executable, args: [cli] };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function executableFile(path) {
+    try {
+        if (!(await stat(path)).isFile())
+            return false;
+        await access(path, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=worktree-editor.js.map

package/runtime/dist/src/runtime/worktree-gradle.js

@@ -0,0 +1,318 @@
+function unsupported() {
+    throw new Error('Unsupported or ambiguous Gradle signing configuration');
+}
+function tokenize(text) {
+    if (text.length > 256 * 1024)
+        unsupported();
+    const tokens = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (/\s/.test(text[cursor])) {
+            cursor++;
+            continue;
+        }
+        if (text.startsWith('//', cursor)) {
+            while (cursor < text.length && !/[\r\n]/.test(text[cursor]))
+                cursor++;
+            continue;
+        }
+        if (text.startsWith('/*', cursor)) {
+            let depth = 1;
+            cursor += 2;
+            while (cursor < text.length && depth) {
+                if (text.startsWith('/*', cursor)) {
+                    depth++;
+                    cursor += 2;
+                }
+                else if (text.startsWith('*/', cursor)) {
+                    depth--;
+                    cursor += 2;
+                }
+                else
+                    cursor++;
+            }
+            if (depth)
+                unsupported();
+            continue;
+        }
+        const start = cursor;
+        const quote = text[cursor];
+        if (quote === '"' || quote === "'") {
+            if (text.startsWith(quote.repeat(3), cursor)) {
+                const end = text.indexOf(quote.repeat(3), cursor + 3);
+                if (end < 0)
+                    unsupported();
+                cursor = end + 3;
+                tokens.push({ kind: 'string', value: '', literal: false, start, end: cursor });
+                continue;
+            }
+            cursor++;
+            let value = '';
+            let literal = true;
+            while (cursor < text.length && text[cursor] !== quote) {
+                let character = text[cursor++];
+                if (/[\r\n]/.test(character))
+                    unsupported();
+                if (character === '\\') {
+                    character = text[cursor++] ?? '';
+                    if (character === 'u') {
+                        const digits = text.slice(cursor, cursor + 4);
+                        if (!/^[a-fA-F0-9]{4}$/.test(digits))
+                            unsupported();
+                        value += String.fromCharCode(parseInt(digits, 16));
+                        cursor += 4;
+                    }
+                    else if ('\\\'"'.includes(character) && character)
+                        value += character;
+                    else {
+                        literal = false;
+                        value += character;
+                    }
+                }
+                else {
+                    if (character === '$')
+                        literal = false;
+                    value += character;
+                }
+            }
+            if (text[cursor++] !== quote)
+                unsupported();
+            tokens.push({ kind: 'string', value, literal, start, end: cursor });
+            continue;
+        }
+        const word = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(text.slice(cursor))?.[0];
+        cursor += word?.length ?? 1;
+        tokens.push({ kind: word ? 'word' : 'symbol', value: word ?? quote, start, end: cursor });
+    }
+    return tokens;
+}
+export function parseGradleSigning(text) {
+    const tokens = tokenize(text);
+    const signing = tokens.flatMap((token, index) => token.kind === 'word' && ['storeFile', 'setStoreFile'].includes(token.value) ? [index] : []);
+    if (!signing.length)
+        return null;
+    const value = (index) => tokens[index]?.value;
+    const expect = (index, expected) => {
+        if (value(index) !== expected || tokens[index]?.kind === 'string')
+            unsupported();
+        return index + 1;
+    };
+    const word = (index) => {
+        if (tokens[index]?.kind !== 'word')
+            unsupported();
+        return tokens[index].value;
+    };
+    const literal = (index) => {
+        const token = tokens[index];
+        if (token?.kind !== 'string' || !token.literal || !token.value || token.value.includes('$'))
+            unsupported();
+        return token.value;
+    };
+    const scopes = [];
+    const braces = [];
+    for (const [index, token] of tokens.entries()) {
+        scopes.push(braces.at(-1) ?? -1);
+        if (token.kind !== 'symbol')
+            continue;
+        if (token.value === '{')
+            braces.push(index);
+        if (token.value === '}' && braces.pop() === undefined)
+            unsupported();
+    }
+    if (braces.length)
+        unsupported();
+    const startStatement = (index) => {
+        if (!index ||
+            (tokens[index - 1]?.kind === 'symbol' && [';', '{', '}'].includes(value(index - 1))))
+            return;
+        const previous = value(index - 1);
+        if (!/[\r\n]/.test(text.slice(tokens[index - 1].end, tokens[index].start)) ||
+            ['=', '(', '[', ',', '.', '?', ':', '+', '-', '*', '/', 'else', 'do'].includes(previous))
+            unsupported();
+        if (previous === ')') {
+            let cursor = index - 1;
+            let depth = 0;
+            do {
+                if (tokens[cursor]?.kind !== 'string') {
+                    if (value(cursor) === ')')
+                        depth++;
+                    if (value(cursor) === '(')
+                        depth--;
+                }
+                cursor--;
+            } while (cursor >= 0 && depth);
+            if (['if', 'for', 'while', 'when', 'catch'].includes(value(cursor)))
+                unsupported();
+        }
+    };
+    const endStatement = (index) => {
+        if (index === tokens.length ||
+            (tokens[index]?.kind === 'symbol' && [';', '}'].includes(value(index))))
+            return;
+        const gap = text.slice(tokens[index - 1].end, tokens[index].start);
+        if (!/[\r\n]/.test(gap) ||
+            [
+                '.',
+                '?',
+                '+',
+                '-',
+                '*',
+                '/',
+                '%',
+                '[',
+                '(',
+                '=',
+                '&',
+                '|',
+                '^',
+                '<',
+                '>',
+                '!',
+                '{',
+                ':',
+                ',',
+                'as',
+                'in',
+                'instanceof',
+            ].includes(value(index)))
+            unsupported();
+    };
+    const fileCall = (index) => {
+        word(index);
+        const root = value(index) === 'rootProject';
+        if (root || value(index) === 'project')
+            index = expect(index + 1, '.');
+        index = expect(index, 'file');
+        return { index: expect(index, '('), root };
+    };
+    const access = (index) => {
+        if (value(index) === '[') {
+            const key = literal(index + 1);
+            return { key, next: expect(index + 2, ']') };
+        }
+        index = expect(index, '.');
+        index = expect(index, 'getProperty');
+        index = expect(index, '(');
+        const key = literal(index++);
+        return { key, next: expect(index, ')') };
+    };
+    const declaration = (name, type) => {
+        const matches = tokens.flatMap((token, index) => {
+            if (token.kind !== 'word' ||
+                token.value !== name ||
+                tokens[index - 1]?.kind !== 'word' ||
+                !['def', 'val', 'var', type].includes(value(index - 1)))
+                return [];
+            if (scopes[index] !== -1)
+                unsupported();
+            startStatement(index - 1);
+            let next = index + 1;
+            if (value(next) === ':')
+                next = expect(next + 1, type);
+            return [{ index, next: expect(next, '=') }];
+        });
+        if (matches.length !== 1)
+            unsupported();
+        return matches[0];
+    };
+    let propertiesName;
+    let keyRoot = false;
+    const signingReads = new Set();
+    for (const start of signing) {
+        startStatement(start);
+        if (value(start) !== 'storeFile' || ['.', 'def', 'val', 'var'].includes(value(start - 1)))
+            unsupported();
+        let index = start + 1;
+        if (value(index) === '=')
+            index++;
+        const call = fileCall(index);
+        index = call.index;
+        const name = word(index);
+        signingReads.add(index++);
+        if (propertiesName && (propertiesName !== name || keyRoot !== call.root))
+            unsupported();
+        propertiesName = name;
+        keyRoot = call.root;
+        const read = access(index);
+        if (read.key !== 'storeFile')
+            unsupported();
+        index = read.next;
+        if (value(index) === 'as')
+            index = expect(index + 1, 'String');
+        endStatement(expect(index, ')'));
+    }
+    const properties = declaration(propertiesName, 'Properties');
+    let index = properties.next;
+    if (value(index) === 'new')
+        index++;
+    index = expect(index, 'Properties');
+    index = expect(index, '(');
+    endStatement(expect(index, ')'));
+    const loads = [];
+    for (const [position, token] of tokens.entries()) {
+        if (token.kind !== 'word' ||
+            token.value !== propertiesName ||
+            position === properties.index ||
+            signingReads.has(position))
+            continue;
+        if (value(position - 1) === '.')
+            unsupported();
+        if (value(position + 1) === '.' && value(position + 2) === 'load') {
+            let next = expect(position + 3, '(');
+            if (value(next) === 'new')
+                next++;
+            next = expect(next, 'FileInputStream');
+            next = expect(next, '(');
+            const fileIndex = next;
+            const fileName = word(next++);
+            next = expect(next, ')');
+            endStatement(expect(next, ')'));
+            loads.push({ index: position, fileIndex, fileName });
+        }
+        else {
+            const read = access(position + 1);
+            if (tokens[read.next]?.kind === 'symbol' &&
+                ![')', ']', '}', ',', ';'].includes(value(read.next)))
+                unsupported();
+        }
+    }
+    if (loads.length !== 1)
+        unsupported();
+    const load = loads[0];
+    startStatement(load.index);
+    const scope = scopes[load.index];
+    if (scope !== -1) {
+        if (scopes[scope] !== -1)
+            unsupported();
+        let guard = scope - 8;
+        if (guard < 0)
+            unsupported();
+        startStatement(guard);
+        for (const expected of ['if', '(', load.fileName, '.', 'exists', '(', ')', ')']) {
+            guard = expect(guard, expected);
+        }
+    }
+    if (properties.index >= load.index || signing.some((position) => position <= load.index))
+        unsupported();
+    const source = declaration(load.fileName, 'File');
+    if (source.index >= load.index)
+        unsupported();
+    const call = fileCall(source.next);
+    const propertiesPath = literal(call.index);
+    endStatement(expect(call.index + 1, ')'));
+    for (const [position, token] of tokens.entries()) {
+        if (token.kind !== 'word' ||
+            token.value !== load.fileName ||
+            position === source.index ||
+            position === load.fileIndex)
+            continue;
+        if (value(position - 1) === '.')
+            unsupported();
+        let next = expect(position + 1, '.');
+        next = expect(next, 'exists');
+        next = expect(next, '(');
+        expect(next, ')');
+    }
+    return { propertiesPath, propertiesRoot: call.root, keyRoot };
+}
+//# sourceMappingURL=worktree-gradle.js.map