psadk 1.4.8 → 1.5.1

package/build/main/lib/agent-core/src/harness/env/nodejs.js

@@ -0,0 +1,494 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { constants, createReadStream } from 'node:fs';
+import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { err, ExecutionError, FileError, ok, toError, } from "../types.js";
+function resolvePath(cwd, path) {
+    return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function fileKindFromStats(stats) {
+    if (stats.isFile())
+        return 'file';
+    if (stats.isDirectory())
+        return 'directory';
+    if (stats.isSymbolicLink())
+        return 'symlink';
+    return undefined;
+}
+function fileInfoFromStats(path, stats) {
+    const kind = fileKindFromStats(stats);
+    if (!kind)
+        return err(new FileError('invalid', 'Unsupported file type', path));
+    return ok({
+        name: path.replace(/\/+$/, '').split('/').pop() ?? path,
+        path,
+        kind,
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+    });
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function toFileError(error, path) {
+    if (error instanceof FileError)
+        return error;
+    const cause = toError(error);
+    if (isNodeError(error)) {
+        const message = error.message;
+        switch (error.code) {
+            case 'ABORT_ERR':
+                return new FileError('aborted', message, path, cause);
+            case 'ENOENT':
+                return new FileError('not_found', message, path, cause);
+            case 'EACCES':
+            case 'EPERM':
+                return new FileError('permission_denied', message, path, cause);
+            case 'ENOTDIR':
+                return new FileError('not_directory', message, path, cause);
+            case 'EISDIR':
+                return new FileError('is_directory', message, path, cause);
+            case 'EINVAL':
+                return new FileError('invalid', message, path, cause);
+        }
+    }
+    return new FileError('unknown', cause.message, path, cause);
+}
+function abortResult(signal, path) {
+    return signal?.aborted
+        ? err(new FileError('aborted', 'aborted', path))
+        : undefined;
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runCommand(command, args, timeoutMs) {
+    return await new Promise((resolve) => {
+        let stdout = '';
+        let child;
+        try {
+            child = spawn(command, args, {
+                stdio: ['ignore', 'pipe', 'ignore'],
+                windowsHide: true,
+            });
+        }
+        catch {
+            resolve({ stdout: '', status: null });
+            return;
+        }
+        const timeout = setTimeout(() => {
+            if (child.pid)
+                killProcessTree(child.pid);
+        }, timeoutMs);
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.on('error', () => {
+            clearTimeout(timeout);
+            resolve({ stdout: '', status: null });
+        });
+        child.on('close', (status) => {
+            clearTimeout(timeout);
+            resolve({ stdout, status });
+        });
+    });
+}
+async function findBashOnPath() {
+    const result = process.platform === 'win32'
+        ? await runCommand('where', ['bash.exe'], 5000)
+        : await runCommand('which', ['bash'], 5000);
+    if (result.status !== 0 || !result.stdout)
+        return null;
+    const firstMatch = result.stdout.trim().split(/\r?\n/)[0];
+    return firstMatch && (await pathExists(firstMatch)) ? firstMatch : null;
+}
+async function getShellConfig(customShellPath) {
+    if (customShellPath) {
+        if (await pathExists(customShellPath)) {
+            return ok({ shell: customShellPath, args: ['-c'] });
+        }
+        return err(new ExecutionError('shell_unavailable', `Custom shell path not found: ${customShellPath}`));
+    }
+    if (process.platform === 'win32') {
+        const candidates = [];
+        const programFiles = process.env.ProgramFiles;
+        if (programFiles)
+            candidates.push(`${programFiles}\\Git\\bin\\bash.exe`);
+        const programFilesX86 = process.env['ProgramFiles(x86)'];
+        if (programFilesX86)
+            candidates.push(`${programFilesX86}\\Git\\bin\\bash.exe`);
+        for (const candidate of candidates) {
+            if (await pathExists(candidate)) {
+                return ok({ shell: candidate, args: ['-c'] });
+            }
+        }
+        const bashOnPath = await findBashOnPath();
+        if (bashOnPath) {
+            return ok({ shell: bashOnPath, args: ['-c'] });
+        }
+        return err(new ExecutionError('shell_unavailable', 'No bash shell found'));
+    }
+    if (await pathExists('/bin/bash')) {
+        return ok({ shell: '/bin/bash', args: ['-c'] });
+    }
+    const bashOnPath = await findBashOnPath();
+    if (bashOnPath) {
+        return ok({ shell: bashOnPath, args: ['-c'] });
+    }
+    return ok({ shell: 'sh', args: ['-c'] });
+}
+function getShellEnv(baseEnv, extraEnv) {
+    return {
+        ...process.env,
+        ...baseEnv,
+        ...extraEnv,
+    };
+}
+function killProcessTree(pid) {
+    if (process.platform === 'win32') {
+        try {
+            spawn('taskkill', ['/F', '/T', '/PID', String(pid)], {
+                stdio: 'ignore',
+                detached: true,
+                windowsHide: true,
+            });
+        }
+        catch {
+            // Ignore errors.
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // Process already dead.
+        }
+    }
+}
+export class NodeExecutionEnv {
+    cwd;
+    shellPath;
+    shellEnv;
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.shellPath = options.shellPath;
+        this.shellEnv = options.shellEnv;
+    }
+    async absolutePath(path) {
+        return ok(resolvePath(this.cwd, path));
+    }
+    async joinPath(parts) {
+        return ok(join(...parts));
+    }
+    async exec(command, options) {
+        if (options?.abortSignal?.aborted)
+            return err(new ExecutionError('aborted', 'aborted'));
+        const cwd = options?.cwd ? resolvePath(this.cwd, options.cwd) : this.cwd;
+        const shellConfig = await getShellConfig(this.shellPath);
+        if (!shellConfig.ok)
+            return shellConfig;
+        return await new Promise((resolvePromise) => {
+            let stdout = '';
+            let stderr = '';
+            let settled = false;
+            let timedOut = false;
+            let callbackError;
+            let child;
+            const timeoutId = typeof options?.timeout === 'number'
+                ? setTimeout(() => {
+                    timedOut = true;
+                    if (child?.pid) {
+                        killProcessTree(child.pid);
+                    }
+                }, options.timeout * 1000)
+                : undefined;
+            const onAbort = () => {
+                if (child?.pid) {
+                    killProcessTree(child.pid);
+                }
+            };
+            const settle = (result) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (options?.abortSignal)
+                    options.abortSignal.removeEventListener('abort', onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                resolvePromise(result);
+            };
+            try {
+                child = spawn(shellConfig.value.shell, [...shellConfig.value.args, command], {
+                    cwd,
+                    detached: process.platform !== 'win32',
+                    env: getShellEnv(this.shellEnv, options?.env),
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                const cause = toError(error);
+                settle(err(new ExecutionError('spawn_error', cause.message, cause)));
+                return;
+            }
+            if (options?.abortSignal) {
+                if (options.abortSignal.aborted) {
+                    onAbort();
+                }
+                else {
+                    options.abortSignal.addEventListener('abort', onAbort, {
+                        once: true,
+                    });
+                }
+            }
+            child.stdout?.setEncoding('utf8');
+            child.stderr?.setEncoding('utf8');
+            child.stdout?.on('data', (chunk) => {
+                stdout += chunk;
+                try {
+                    options?.onStdout?.(chunk);
+                }
+                catch (error) {
+                    const cause = toError(error);
+                    callbackError = new ExecutionError('callback_error', cause.message, cause);
+                    onAbort();
+                }
+            });
+            child.stderr?.on('data', (chunk) => {
+                stderr += chunk;
+                try {
+                    options?.onStderr?.(chunk);
+                }
+                catch (error) {
+                    const cause = toError(error);
+                    callbackError = new ExecutionError('callback_error', cause.message, cause);
+                    onAbort();
+                }
+            });
+            child.on('error', (error) => {
+                settle(err(new ExecutionError('spawn_error', error.message, error)));
+            });
+            child.on('close', (code) => {
+                if (callbackError) {
+                    settle(err(callbackError));
+                    return;
+                }
+                if (timedOut) {
+                    settle(err(new ExecutionError('timeout', `timeout:${options?.timeout}`)));
+                    return;
+                }
+                if (options?.abortSignal?.aborted) {
+                    settle(err(new ExecutionError('aborted', 'aborted')));
+                    return;
+                }
+                settle(ok({ stdout, stderr, exitCode: code ?? 0 }));
+            });
+        });
+    }
+    async readTextFile(path, abortSignal) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        try {
+            return ok(await readFile(resolved, { encoding: 'utf8', signal: abortSignal }));
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async readTextLines(path, options) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(options?.abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        if (options?.maxLines !== undefined && options.maxLines <= 0)
+            return ok([]);
+        let stream;
+        let lineReader;
+        try {
+            stream = createReadStream(resolved, {
+                encoding: 'utf8',
+                signal: options?.abortSignal,
+            });
+            lineReader = createInterface({ input: stream, crlfDelay: Infinity });
+            const lines = [];
+            for await (const line of lineReader) {
+                const loopAbort = abortResult(options?.abortSignal, resolved);
+                if (loopAbort)
+                    return loopAbort;
+                lines.push(line);
+                if (options?.maxLines !== undefined && lines.length >= options.maxLines)
+                    break;
+            }
+            const afterReadAbort = abortResult(options?.abortSignal, resolved);
+            if (afterReadAbort)
+                return afterReadAbort;
+            return ok(lines);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+        finally {
+            lineReader?.close();
+            stream?.destroy();
+        }
+    }
+    async readBinaryFile(path, abortSignal) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        try {
+            return ok(await readFile(resolved, { signal: abortSignal }));
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async writeFile(path, content, abortSignal) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        try {
+            await mkdir(resolve(resolved, '..'), { recursive: true });
+            const afterMkdirAbort = abortResult(abortSignal, resolved);
+            if (afterMkdirAbort)
+                return afterMkdirAbort;
+            await writeFile(resolved, content, { signal: abortSignal });
+            return ok(undefined);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async appendFile(path, content) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            await mkdir(resolve(resolved, '..'), { recursive: true });
+            await appendFile(resolved, content);
+            return ok(undefined);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async fileInfo(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return fileInfoFromStats(resolved, await lstat(resolved));
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async listDir(path, abortSignal) {
+        const resolved = resolvePath(this.cwd, path);
+        const aborted = abortResult(abortSignal, resolved);
+        if (aborted)
+            return aborted;
+        try {
+            const entries = await readdir(resolved, { withFileTypes: true });
+            const infos = [];
+            for (const entry of entries) {
+                const loopAbort = abortResult(abortSignal, resolved);
+                if (loopAbort)
+                    return loopAbort;
+                const entryPath = resolve(resolved, entry.name);
+                try {
+                    const info = fileInfoFromStats(entryPath, await lstat(entryPath));
+                    if (info.ok)
+                        infos.push(info.value);
+                }
+                catch (error) {
+                    return err(toFileError(error, entryPath));
+                }
+            }
+            return ok(infos);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async canonicalPath(path) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            return ok(await realpath(resolved));
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async exists(path) {
+        const result = await this.fileInfo(path);
+        if (result.ok)
+            return ok(true);
+        if (result.error.code === 'not_found')
+            return ok(false);
+        return err(result.error);
+    }
+    async createDir(path, options) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            await mkdir(resolved, { recursive: options?.recursive ?? true });
+            return ok(undefined);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async remove(path, options) {
+        const resolved = resolvePath(this.cwd, path);
+        try {
+            await rm(resolved, {
+                recursive: options?.recursive ?? false,
+                force: options?.force ?? false,
+            });
+            return ok(undefined);
+        }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
+    }
+    async createTempDir(prefix = 'tmp-') {
+        try {
+            return ok(await mkdtemp(join(tmpdir(), prefix)));
+        }
+        catch (error) {
+            return err(toFileError(error));
+        }
+    }
+    async createTempFile(options) {
+        const dir = await this.createTempDir('tmp-');
+        if (!dir.ok)
+            return dir;
+        const filePath = join(dir.value, `${options?.prefix ?? ''}${randomUUID()}${options?.suffix ?? ''}`);
+        try {
+            await writeFile(filePath, '');
+            return ok(filePath);
+        }
+        catch (error) {
+            return err(toFileError(error, filePath));
+        }
+    }
+    async cleanup() {
+        // nothing to clean up for the local node implementation
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodejs.js","sourceRoot":"","sources":["../../../../../../../src/lib/agent-core/src/harness/env/nodejs.ts"],"names":[],"mappings":"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"}

package/build/main/lib/agent-core/{harness → src/harness}/messages.d.ts

@@ -1,5 +1,5 @@
 import type { ImageContent, Message, TextContent } from '@earendil-works/pi-ai';
-import type { AgentMessage } from '../types.js';
+import type { AgentMessage } from '../types.ts';
 export declare const COMPACTION_SUMMARY_PREFIX = "The conversation history before this point was compacted into the following summary:\n\n<summary>\n";
 export declare const COMPACTION_SUMMARY_SUFFIX = "\n</summary>";
 export declare const BRANCH_SUMMARY_PREFIX = "The following is a summary of a branch that this conversation came back from:\n\n<summary>\n";
@@ -35,7 +35,7 @@ export interface CompactionSummaryMessage {
     tokensBefore: number;
     timestamp: number;
 }
-declare module '../types.js' {
+declare module '../types.ts' {
     interface CustomAgentMessages {
         bashExecution: BashExecutionMessage;
         custom: CustomMessage;

package/build/{module/lib/agent-core → main/lib/agent-core/src}/harness/messages.js

@@ -113,4 +113,4 @@ export function convertToLlm(messages) {
     })
         .filter((m) => m !== undefined);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/agent-core/{harness → src/harness}/prompt-templates.d.ts

@@ -1,8 +1,11 @@
-import type { ExecutionEnv, PromptTemplate } from './types.js';
+import { type ExecutionEnv, type PromptTemplate } from './types.ts';
+export type PromptTemplateDiagnosticCode = 'file_info_failed' | 'list_failed' | 'read_failed' | 'parse_failed';
 /** Warning produced while loading prompt templates. */
 export interface PromptTemplateDiagnostic {
     /** Diagnostic severity. Currently only warnings are emitted. */
     type: 'warning';
+    /** Stable diagnostic code. */
+    code: PromptTemplateDiagnosticCode;
     /** Human-readable diagnostic message. */
     message: string;
     /** Path associated with the diagnostic. */