@qvac/harness 0.0.0 → 0.1.1

package/dist-lib/lib/tools/exec/obsidian/vault-write.js

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+import { markdownFileName } from "./note-name.js";
+import { appendToFile, dailyCandidates, ensureWithinRoot, FRONTMATTER_RE, getArg, getContentArg, moveFile, readFileSnapshot, resolveNotePath, todayStamp, updateFileText, writeIfUnchanged } from "./vault-paths.js";
+export function handleAppend(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const content = getContentArg(args);
+    if (!content)
+        throw new Error('Missing required argument: content=');
+    appendToFile(notePath, content);
+    return `Appended to: ${path.relative(vaultPath, notePath)}`;
+}
+export function handlePrepend(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const content = getContentArg(args);
+    if (!content)
+        throw new Error('Missing required argument: content=');
+    updateFileText(notePath, (existing) => content + existing);
+    return `Prepended to: ${path.relative(vaultPath, notePath)}`;
+}
+function uniqueTrashPath(base) {
+    if (!fs.existsSync(base))
+        return base;
+    const ext = base.endsWith('.md') ? '.md' : '';
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    let n = 1;
+    while (fs.existsSync(`${stem} (${n})${ext}`))
+        n += 1;
+    return `${stem} (${n})${ext}`;
+}
+export function handleDelete(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const root = path.resolve(vaultPath);
+    const trashPath = uniqueTrashPath(ensureWithinRoot(vaultPath, path.join('.trash', path.relative(root, notePath))));
+    fs.mkdirSync(path.dirname(trashPath), { recursive: true });
+    moveFile(notePath, trashPath);
+    return `Moved to trash: ${path.relative(vaultPath, notePath)}`;
+}
+export function handleMove(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const to = getArg(args, 'to');
+    if (!to)
+        throw new Error('Missing required argument: to=');
+    const destDir = ensureWithinRoot(vaultPath, to);
+    if (!fs.existsSync(destDir))
+        fs.mkdirSync(destDir, { recursive: true });
+    const destPath = path.join(destDir, path.basename(notePath));
+    moveFile(notePath, destPath);
+    return `Moved to: ${path.relative(vaultPath, destPath)}`;
+}
+export function handleRename(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const newName = getArg(args, 'name');
+    if (!newName)
+        throw new Error('Missing required argument: name=');
+    const fileName = markdownFileName(newName);
+    const relativeDir = path.relative(path.resolve(vaultPath), path.dirname(notePath));
+    const destPath = ensureWithinRoot(vaultPath, path.join(relativeDir, fileName));
+    moveFile(notePath, destPath);
+    return `Renamed to: ${path.relative(vaultPath, destPath)}`;
+}
+function mergeIntoFrontmatter(fmBlock, newProps) {
+    let result = fmBlock;
+    for (const { key, value } of newProps) {
+        const lineRe = new RegExp(`^${key}:.*$`, 'm');
+        if (lineRe.test(result))
+            result = result.replace(lineRe, `${key}: ${value}`);
+        else
+            result += `\n${key}: ${value}`;
+    }
+    return result;
+}
+export function handlePropertySet(vaultPath, args) {
+    const notePath = resolveNotePath(vaultPath, args);
+    if (!notePath || !fs.existsSync(notePath)) {
+        throw new Error(`Note not found. Args: ${args.join(', ')}`);
+    }
+    const propArgs = args.filter((a) => !a.startsWith('file=') && !a.startsWith('path=') && a.includes('='));
+    if (propArgs.length === 0)
+        throw new Error('No property key=value pairs provided.');
+    const newProps = propArgs.map((a) => {
+        const eqIdx = a.indexOf('=');
+        return { key: a.slice(0, eqIdx), value: a.slice(eqIdx + 1) };
+    });
+    updateFileText(notePath, (content) => {
+        const fmBlock = content.match(FRONTMATTER_RE)?.[1];
+        if (fmBlock === undefined) {
+            const lines = newProps.map(({ key, value }) => `${key}: ${value}`);
+            return `---\n${lines.join('\n')}\n---\n${content}`;
+        }
+        const merged = mergeIntoFrontmatter(fmBlock, newProps);
+        return content.replace(FRONTMATTER_RE, `---\n${merged}\n---`);
+    });
+    return `Properties updated: ${newProps.map((p) => p.key).join(', ')}`;
+}
+export function handleDailyAppend(vaultPath, args) {
+    const content = getContentArg(args);
+    if (!content)
+        throw new Error('Missing required argument: content=');
+    const dateStr = todayStamp();
+    let target = null;
+    for (const candidate of dailyCandidates(vaultPath, dateStr)) {
+        if (fs.existsSync(candidate)) {
+            target = candidate;
+            break;
+        }
+    }
+    if (!target) {
+        const dailyDir = ensureWithinRoot(vaultPath, 'Daily Notes');
+        if (!fs.existsSync(dailyDir))
+            fs.mkdirSync(dailyDir, { recursive: true });
+        target = ensureWithinRoot(vaultPath, path.join('Daily Notes', `${dateStr}.md`));
+        const snap = readFileSnapshot(target);
+        if (!snap)
+            writeIfUnchanged(target, '', null);
+    }
+    appendToFile(target, content);
+    return `Appended to daily note: ${dateStr}`;
+}

package/dist-lib/lib/tools/exec/runner.d.ts

@@ -0,0 +1,62 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+export type ExecAttachment = {
+    readonly attachmentId: string;
+    readonly fileName: string;
+    readonly byteLength: number;
+};
+export type RejectedOutput = {
+    readonly name: string;
+    readonly reason: string;
+};
+export type ExecResult = {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+    readonly attachments?: readonly ExecAttachment[];
+    readonly missingOutputs?: readonly string[];
+    readonly rejectedOutputs?: readonly RejectedOutput[];
+};
+export type SpawnOptions = {
+    cwd?: string;
+    shell?: boolean;
+    detached?: boolean;
+    stdio?: [string, string, string] | string;
+    env?: Record<string, string>;
+};
+export type Child = {
+    readonly pid?: number;
+    readonly stdout: {
+        on(event: 'data', handler: (chunk: Buffer | string) => void): void;
+    } | null;
+    readonly stderr: {
+        on(event: 'data', handler: (chunk: Buffer | string) => void): void;
+    } | null;
+    kill(signum?: number | string): void;
+    on(event: 'exit', handler: (code: number | null, signal?: string | null) => void): void;
+    on(event: 'error', handler: (err: Error) => void): void;
+};
+export type SpawnFn = (command: string, opts?: SpawnOptions) => Child;
+export type RunCommandOptions = {
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly timeoutMs?: number;
+    readonly maxOutputChars?: number;
+    readonly signal?: BareAbortSignal;
+    readonly spawn: SpawnFn;
+    readonly killProcess?: KillProcess;
+    readonly platform?: string;
+};
+export declare const MAX_OUTPUT_CHARS = 8192;
+export declare const MAX_OUTPUT_CHARS_LIMIT = 65536;
+export declare const TRUNCATED_OUTPUT_SUFFIX = "\u2026 [truncated]";
+export type KillProcess = (pid: number, signal: string) => void;
+type CapturedOutput = {
+    value: string;
+    truncated: boolean;
+};
+export declare function capOutput(text: string, limit: number): string;
+export declare function appendOutput(output: CapturedOutput, chunk: Buffer | string, limit: number): void;
+export declare function formatOutput(output: CapturedOutput): string;
+export declare function createCapturedOutput(): CapturedOutput;
+export declare function runCommand(command: string, options: RunCommandOptions): Promise<ExecResult>;
+export {};

package/dist-lib/lib/tools/exec/runner.js

@@ -0,0 +1,87 @@
+import process from 'process';
+import { AbortedError } from "../../helpers/race-abort.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+export const MAX_OUTPUT_CHARS = 8_192;
+export const MAX_OUTPUT_CHARS_LIMIT = 65_536;
+export const TRUNCATED_OUTPUT_SUFFIX = '… [truncated]';
+export function capOutput(text, limit) {
+    const body = text.endsWith(TRUNCATED_OUTPUT_SUFFIX)
+        ? text.slice(0, -TRUNCATED_OUTPUT_SUFFIX.length)
+        : text;
+    if (body.length <= limit) {
+        return body === text ? text : `${body}${TRUNCATED_OUTPUT_SUFFIX}`;
+    }
+    return `${body.slice(0, limit)}${TRUNCATED_OUTPUT_SUFFIX}`;
+}
+export function appendOutput(output, chunk, limit) {
+    if (output.truncated)
+        return;
+    const available = limit - output.value.length;
+    if (available <= 0) {
+        output.truncated = true;
+        return;
+    }
+    const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    output.value += text.slice(0, available);
+    output.truncated = text.length > available;
+}
+export function formatOutput(output) {
+    return output.truncated ? `${output.value}${TRUNCATED_OUTPUT_SUFFIX}` : output.value;
+}
+export function createCapturedOutput() {
+    return { value: '', truncated: false };
+}
+function terminateProcessTree(child, killProcess) {
+    if (child.pid !== undefined && killProcess) {
+        try {
+            killProcess(-child.pid, 'SIGTERM');
+            return;
+        }
+        catch {
+        }
+    }
+    child.kill('SIGTERM');
+}
+export function runCommand(command, options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
+    if (options.signal?.aborted)
+        return Promise.reject(new AbortedError());
+    return new Promise((resolve, reject) => {
+        const stdout = { value: '', truncated: false };
+        const stderr = { value: '', truncated: false };
+        let settled = false;
+        const child = options.spawn(command, {
+            shell: true,
+            detached: (options.platform ?? process.platform) !== 'win32',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: options.cwd,
+            ...(options.env ? { env: { ...options.env } } : {})
+        });
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            finish(() => reject(new AbortedError()));
+            terminateProcessTree(child, options.killProcess);
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => {
+            finish(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)));
+            terminateProcessTree(child, options.killProcess);
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => appendOutput(stdout, chunk, maxOutputChars));
+        child.stderr?.on('data', (chunk) => appendOutput(stderr, chunk, maxOutputChars));
+        child.on('error', (err) => finish(() => reject(err)));
+        child.on('exit', (code) => finish(() => resolve({
+            stdout: formatOutput(stdout),
+            stderr: formatOutput(stderr),
+            exitCode: code ?? 1
+        })));
+    });
+}

package/dist-lib/lib/tools/exec/scope.d.ts

@@ -0,0 +1,3 @@
+export declare function bareBin(token: string): string | null;
+export declare function firstCommandToken(command: string): string;
+export declare function sanitizeCommand(command: string): string | null;

package/dist-lib/lib/tools/exec/scope.js

@@ -0,0 +1,97 @@
+export function bareBin(token) {
+    if (!token || /[/\\~$]/.test(token))
+        return null;
+    return token.replace(/\.exe$/i, '').toLowerCase();
+}
+export function firstCommandToken(command) {
+    const chars = [...command];
+    let i = 0;
+    while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t'))
+        i++;
+    let token = '';
+    while (i < chars.length) {
+        const c = chars[i];
+        if (c === '"' || c === "'") {
+            const quote = c;
+            i++;
+            while (i < chars.length && chars[i] !== quote) {
+                token += chars[i];
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (c === ' ' || c === '\t' || c === '\n')
+            break;
+        if (c === ';' || c === '&' || c === '|' || c === '>' || c === '<' || c === '`')
+            break;
+        token += c;
+        i++;
+    }
+    return token;
+}
+function isPad(c) {
+    return c === ' ' || c === '\t' || c === '\n';
+}
+export function sanitizeCommand(command) {
+    const chars = [...command];
+    let i = 0;
+    while (i < chars.length) {
+        const c = chars[i];
+        if (c === '\n') {
+            i++;
+            while (i < chars.length && isPad(chars[i]))
+                i++;
+            if (i < chars.length)
+                return 'command must not span multiple lines';
+            return null;
+        }
+        if (c === "'") {
+            i++;
+            while (i < chars.length && chars[i] !== "'")
+                i++;
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            i++;
+            while (i < chars.length && chars[i] !== '"') {
+                if (chars[i] === '\\') {
+                    if (chars[i + 1] === '\n')
+                        return 'command must not use line continuations';
+                    i += 2;
+                    continue;
+                }
+                if (chars[i] === '`')
+                    return 'command must not use backtick substitution';
+                if (chars[i] === '$')
+                    return 'command must not use shell expansion';
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (c === '\\') {
+            if (chars[i + 1] === '\n')
+                return 'command must not use line continuations';
+            i += 2;
+            continue;
+        }
+        if (c === '`')
+            return 'command must not use backtick substitution';
+        if (c === '$')
+            return 'command must not use shell expansion';
+        if (c === ';')
+            return 'command must not chain with ;';
+        if (c === '&')
+            return 'command must not use & or &&';
+        if (c === '|')
+            return 'command must not use pipes';
+        if (c === '>')
+            return 'command must not redirect output';
+        if (c === '<')
+            return 'command must not redirect input';
+        i++;
+    }
+    return null;
+}

package/dist-lib/lib/tools/exec/shell-argv.d.ts

@@ -0,0 +1,2 @@
+export declare function shellEscapeArg(value: string): string;
+export declare function shellArgv(command: string): string[];

package/dist-lib/lib/tools/exec/shell-argv.js

@@ -0,0 +1,48 @@
+export function shellEscapeArg(value) {
+    return value.replace(/[\\'" \t\n]/g, '\\$&');
+}
+export function shellArgv(command) {
+    const chars = [...command];
+    const out = [];
+    let i = 0;
+    while (i < chars.length) {
+        while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t'))
+            i++;
+        if (i >= chars.length)
+            break;
+        if (chars[i] === '\n')
+            break;
+        let token = '';
+        while (i < chars.length) {
+            const c = chars[i];
+            if (c === ' ' || c === '\t' || c === '\n')
+                break;
+            if (c === "'" || c === '"') {
+                const quote = c;
+                i++;
+                while (i < chars.length && chars[i] !== quote) {
+                    if (quote === '"' && chars[i] === '\\' && i + 1 < chars.length) {
+                        token += chars[i + 1];
+                        i += 2;
+                        continue;
+                    }
+                    token += chars[i];
+                    i++;
+                }
+                if (i < chars.length)
+                    i++;
+                continue;
+            }
+            if (c === '\\' && i + 1 < chars.length) {
+                token += chars[i + 1];
+                i += 2;
+                continue;
+            }
+            token += c;
+            i++;
+        }
+        if (token.length > 0 || out.length > 0)
+            out.push(token);
+    }
+    return out;
+}

package/dist-lib/lib/tools/exec.d.ts

@@ -0,0 +1,29 @@
+import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { LoadPyodideFn } from './exec/adapters/python/pyodide.ts';
+import { type KillProcess, type SpawnFn } from './exec/runner.ts';
+import { type Realpath } from './fs/scope.ts';
+import type { CredentialStoreFn } from './skills/auth-resolver.ts';
+import { type SkillSettingsFn } from './skills/skill-settings.ts';
+export type { ExecResult, KillProcess, SpawnFn } from './exec/runner.ts';
+export interface ExecToolOptions {
+    readonly spawn?: SpawnFn;
+    readonly killProcess?: KillProcess;
+    readonly loadPyodide?: LoadPyodideFn;
+    readonly disablePyodide?: boolean;
+    readonly credentialStore?: CredentialStoreFn;
+    readonly skillSettings?: SkillSettingsFn;
+    readonly realpath?: Realpath;
+    readonly deniedRoots?: readonly string[];
+    readonly skillsDir?: string;
+}
+export declare function bareRuntime(): Promise<{
+    readonly spawn: SpawnFn;
+    readonly killProcess: KillProcess;
+}>;
+export declare function resolveScriptRun(rawArgs: Record<string, unknown>, skillsDir: string | undefined): {
+    args: Record<string, unknown>;
+    trusted: boolean;
+} | {
+    error: string;
+} | null;
+export declare function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide, credentialStore, skillSettings, realpath, deniedRoots, skillsDir }?: ExecToolOptions): ToolDefinition;