vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/project-memory.js

@@ -8,9 +8,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
+import { redactSensitiveText } from './secret-policy.js';
+import { DurableJsonStore } from './durable-json.js';
 const MAX_ITEMS = 240;
 const MAX_TEXT_LENGTH = 320;
 const MAX_CONTEXT_ITEMS = 14;
+const MAX_BRAIN_BYTES = 512 * 1024;
 const STOP_WORDS = new Set([
     'about', 'after', 'again', 'also', 'because', 'before', 'could', 'from', 'have', 'into', 'just', 'make', 'need',
     'only', 'please', 'should', 'that', 'their', 'there', 'this', 'with', 'work', 'working', 'would', 'your', 'vigthoria',
@@ -19,7 +22,7 @@ function nowIso() {
     return new Date().toISOString();
 }
 function normalizeText(value) {
-    return String(value || '')
+    return redactSensitiveText(String(value || ''))
         .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, ' ')
         .replace(/[ \t\r\n]+/g, ' ')
         .trim();
@@ -63,43 +66,75 @@ export class ProjectMemoryService {
     workspacePath;
     memoryDir;
     brainPath;
-    constructor(workspacePath = process.cwd()) {
+    brainStore;
+    enabled;
+    constructor(workspacePath = process.cwd(), options = {}) {
         this.workspacePath = path.resolve(workspacePath || process.cwd());
         this.memoryDir = path.join(this.workspacePath, '.vigthoria', 'memory');
         this.brainPath = path.join(this.memoryDir, 'brain.json');
+        const configured = String(process.env.VIGTHORIA_PROJECT_MEMORY || 'local-only').trim().toLowerCase();
+        this.enabled = options.enabled ?? !['0', 'off', 'false', 'disabled'].includes(configured);
+        this.brainStore = new DurableJsonStore({
+            filePath: this.brainPath,
+            schemaVersion: 2,
+            defaultValue: () => this.emptyBrain(),
+            validate: (value) => Boolean(value && typeof value === 'object'
+                && value.version === 2
+                && value.privacyMode === 'local-only'
+                && Array.isArray(value.items)
+                && Buffer.byteLength(JSON.stringify(value), 'utf8') <= MAX_BRAIN_BYTES),
+            migrate: (value) => {
+                if (!value || typeof value !== 'object' || !Array.isArray(value.items))
+                    return this.emptyBrain();
+                const legacy = value;
+                return {
+                    ...legacy,
+                    version: 2,
+                    privacyMode: 'local-only',
+                    workspaceName: legacy.workspaceName || path.basename(this.workspacePath),
+                    updatedAt: legacy.updatedAt || nowIso(),
+                    items: this.dedupeAndTrim(legacy.items),
+                };
+            },
+        });
     }
     getMemoryDir() {
         return this.memoryDir;
     }
     loadBrain() {
+        if (!this.enabled)
+            return this.emptyBrain();
         try {
-            if (fs.existsSync(this.brainPath)) {
-                const parsed = JSON.parse(fs.readFileSync(this.brainPath, 'utf8'));
-                if (parsed && parsed.version === 1 && Array.isArray(parsed.items)) {
-                    return parsed;
-                }
-            }
+            return this.brainStore.read();
         }
         catch {
             // Corrupt memory should never break chat.
         }
+        return this.emptyBrain();
+    }
+    emptyBrain() {
         return {
-            version: 1,
+            version: 2,
             workspaceName: path.basename(this.workspacePath),
             updatedAt: nowIso(),
+            privacyMode: 'local-only',
             items: [],
         };
     }
     saveBrain(brain) {
+        if (!this.enabled)
+            return;
         try {
-            fs.mkdirSync(this.memoryDir, { recursive: true });
-            const normalized = {
+            fs.mkdirSync(this.memoryDir, { recursive: true, mode: 0o700 });
+            const normalized = this.brainStore.update((current) => ({
+                ...current,
                 ...brain,
-                workspaceName: brain.workspaceName || path.basename(this.workspacePath),
+                version: 2,
+                privacyMode: 'local-only',
+                workspaceName: brain.workspaceName || current.workspaceName || path.basename(this.workspacePath),
                 updatedAt: nowIso(),
-                items: this.dedupeAndTrim(brain.items || []),
-            };
-            fs.writeFileSync(this.brainPath, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
+                items: this.dedupeAndTrim([...(current.items || []), ...(brain.items || [])]),
+            })).data;
             this.writeMarkdownViews(normalized);
         }
         catch {
@@ -107,6 +142,8 @@ export class ProjectMemoryService {
         }
     }
     remember(type, text, options = {}) {
+        if (!this.enabled)
+            return;
         const clean = clampText(text);
         if (!clean || clean.length < 12)
             return;
@@ -116,6 +153,8 @@ export class ProjectMemoryService {
         this.saveBrain(brain);
     }
     rememberConversation(messages, options = {}) {
+        if (!this.enabled)
+            return;
         const recent = (messages || []).slice(-16);
         const candidates = [];
         for (const message of recent) {
@@ -151,6 +190,8 @@ export class ProjectMemoryService {
         this.saveBrain(brain);
     }
     buildContextForPrompt(prompt) {
+        if (!this.enabled)
+            return '';
         const items = this.retrieveRelevantMemory(prompt, MAX_CONTEXT_ITEMS);
         if (items.length === 0)
             return '';
@@ -205,6 +246,8 @@ export class ProjectMemoryService {
             itemCount: brain.items.length,
             updatedAt: brain.updatedAt,
             typeCounts,
+            enabled: this.enabled,
+            privacyMode: 'local-only',
         };
     }
     createItem(type, text, options) {
@@ -270,10 +313,20 @@ export class ProjectMemoryService {
                 continue;
             const heading = this.headingForType(type);
             const lines = [`# ${heading}`, '', ...items.map((item) => `- ${item.text}`)];
-            fs.writeFileSync(path.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n', 'utf8');
+            this.atomicWrite(path.join(this.memoryDir, `${type}s.md`), lines.join('\n') + '\n');
             allLines.push(`## ${heading}`, '', ...items.slice(-40).map((item) => `- ${item.text}`), '');
         }
-        fs.writeFileSync(path.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n', 'utf8');
+        this.atomicWrite(path.join(this.memoryDir, 'README.md'), allLines.join('\n').trimEnd() + '\n');
+    }
+    atomicWrite(targetPath, content) {
+        if (Buffer.byteLength(content, 'utf8') > MAX_BRAIN_BYTES) {
+            throw new Error('Project memory write exceeds size limit');
+        }
+        const temporary = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+        fs.writeFileSync(temporary, content, { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(temporary, targetPath);
+        if (process.platform !== 'win32')
+            fs.chmodSync(targetPath, 0o600);
     }
     headingForType(type) {
         switch (type) {

package/dist/utils/prompt-workspace-resolver.d.ts

@@ -0,0 +1,14 @@
+export interface PromptWorkspaceResolutionOptions {
+    baseWorkspace: string;
+    currentProjectPath: string;
+    cwd: string;
+    configuredProjectRoot?: string | null;
+    additionalRoots?: string[];
+    allowUnscoped?: boolean;
+}
+export interface PromptWorkspaceResolution {
+    resolvedPath: string | null;
+    rejectedPath?: string;
+    allowedRoots: string[];
+}
+export declare function resolvePromptWorkspace(prompt: string, options: PromptWorkspaceResolutionOptions): PromptWorkspaceResolution;

package/dist/utils/prompt-workspace-resolver.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function extractExistingPath(prompt) {
+    const windowsMatch = prompt.match(/([A-Za-z]:[\\/][^\s<>"|?*]*)/);
+    const candidates = windowsMatch ? [windowsMatch[1]] : [];
+    if (!/\b(?:https?|ftp):\/\//i.test(prompt)) {
+        const unixMatch = prompt.match(/(\/(?:[^\s<>"|?*]|\s+(?![^\s<>"|?*]))*)/);
+        if (unixMatch) {
+            candidates.push(unixMatch[1]
+                .trim()
+                .replace(/\s+(and|or|at|in|the|to|for|with|from|by|on)$/i, '')
+                .replace(/[.,;!?:)\]]*$/, '')
+                .trim());
+        }
+    }
+    for (const candidate of candidates) {
+        if (!candidate || candidate === '/')
+            continue;
+        try {
+            const resolved = path.resolve(candidate);
+            if (fs.existsSync(resolved))
+                return fs.realpathSync(resolved);
+        }
+        catch {
+            // Continue to the next syntactic candidate.
+        }
+    }
+    return null;
+}
+function canonicalDirectory(rawValue) {
+    const value = String(rawValue || '').trim();
+    if (!value)
+        return null;
+    try {
+        const resolved = path.resolve(value);
+        if (!fs.statSync(resolved).isDirectory())
+            return null;
+        return fs.realpathSync(resolved);
+    }
+    catch {
+        return null;
+    }
+}
+function isWithin(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+export function resolvePromptWorkspace(prompt, options) {
+    const explicitPath = extractExistingPath(prompt);
+    const allowedRoots = [
+        options.baseWorkspace,
+        options.currentProjectPath,
+        options.cwd,
+        options.configuredProjectRoot,
+        ...(options.additionalRoots || []),
+    ].map(canonicalDirectory).filter((entry) => Boolean(entry));
+    const uniqueRoots = [...new Set(allowedRoots)];
+    if (!explicitPath)
+        return { resolvedPath: null, allowedRoots: uniqueRoots };
+    if (options.allowUnscoped || uniqueRoots.some((root) => isWithin(explicitPath, root))) {
+        return { resolvedPath: explicitPath, allowedRoots: uniqueRoots };
+    }
+    return { resolvedPath: null, rejectedPath: explicitPath, allowedRoots: uniqueRoots };
+}

package/dist/utils/release-install.d.ts

@@ -0,0 +1,11 @@
+export type ReleaseInstallResult = {
+    version: string;
+    versionDirectory: string;
+    currentLink: string;
+    previousTarget: string | null;
+    binDirectory: string;
+};
+export declare function installReleaseTransaction(packageSpec: string, expectedVersion: string, options?: {
+    homeDirectory?: string;
+    npmRegistry?: string;
+}): ReleaseInstallResult;

package/dist/utils/release-install.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { getReleasePolicy } from './release-policy.js';
+import { safeChildProcessEnv } from './secret-policy.js';
+import { assertProcessNetworkAllowed } from './process-policy.js';
+function npmExecutable() { return process.platform === 'win32' ? 'npm.cmd' : 'npm'; }
+function readInstalledIdentity(prefix) {
+    const packageDirectory = path.join(prefix, 'node_modules', 'vigthoria-cli');
+    const manifest = JSON.parse(fs.readFileSync(path.join(packageDirectory, 'package.json'), 'utf8'));
+    return { name: String(manifest.name || ''), version: String(manifest.version || ''), entry: path.join(packageDirectory, 'dist', 'index.js') };
+}
+function smokeCandidate(prefix, expectedVersion, homeDirectory) {
+    const identity = readInstalledIdentity(prefix);
+    if (identity.name !== getReleasePolicy().packageName || identity.version !== expectedVersion)
+        throw new Error('Staged package identity does not match the selected release.');
+    const environment = {
+        ...safeChildProcessEnv(),
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        VIGTHORIA_OFFLINE: '1',
+        VIGTHORIA_NO_BANNER: '1',
+        VIGTHORIA_NO_UPDATE_CHECK: '1',
+        NO_COLOR: '1',
+    };
+    for (const args of [['--version'], ['--help'], ['doctor', '--json']]) {
+        const output = execFileSync(process.execPath, [identity.entry, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, timeout: 30_000, env: environment });
+        if (args[0] === '--version' && output.trim() !== expectedVersion)
+            throw new Error('Staged CLI banner does not match the selected release.');
+    }
+}
+function writeLaunchers(binDirectory, currentLink) {
+    fs.mkdirSync(binDirectory, { recursive: true, mode: 0o700 });
+    const entry = path.join(currentLink, 'node_modules', 'vigthoria-cli', 'dist', 'index.js');
+    if (process.platform === 'win32') {
+        const body = `@echo off\r\n"${process.execPath}" "${entry}" %*\r\n`;
+        for (const name of ['vigthoria.cmd', 'vig.cmd', 'vigthoria-chat.cmd']) {
+            const temporary = path.join(binDirectory, `.${name}.${randomUUID()}.tmp`);
+            fs.writeFileSync(temporary, body, { flag: 'wx' });
+            fs.renameSync(temporary, path.join(binDirectory, name));
+        }
+        return;
+    }
+    const quotedEntry = entry.replaceAll("'", "'\\''");
+    const body = `#!/bin/sh\nexec '${process.execPath}' '${quotedEntry}' "$@"\n`;
+    for (const name of ['vigthoria', 'vig', 'vigthoria-chat']) {
+        const temporary = path.join(binDirectory, `.${name}.${randomUUID()}.tmp`);
+        fs.writeFileSync(temporary, body, { flag: 'wx', mode: 0o755 });
+        fs.renameSync(temporary, path.join(binDirectory, name));
+    }
+}
+export function installReleaseTransaction(packageSpec, expectedVersion, options = {}) {
+    const policy = getReleasePolicy();
+    const homeDirectory = path.resolve(options.homeDirectory || os.homedir());
+    const cliRoot = path.join(homeDirectory, path.normalize(policy.installation.versionsDirectory), '..');
+    const versionsDirectory = path.join(homeDirectory, policy.installation.versionsDirectory);
+    const currentLink = path.join(homeDirectory, policy.installation.currentLink);
+    const binDirectory = path.join(homeDirectory, policy.installation.binDirectory);
+    fs.mkdirSync(versionsDirectory, { recursive: true, mode: 0o700 });
+    const stage = path.join(cliRoot, `.stage-${randomUUID()}`);
+    const destination = path.join(versionsDirectory, expectedVersion);
+    if (fs.existsSync(destination))
+        throw new Error(`Version ${expectedVersion} is already installed; refusing to overwrite it.`);
+    fs.mkdirSync(stage, { recursive: false, mode: 0o700 });
+    let switched = false;
+    let previousTarget = null;
+    try {
+        const npm = npmExecutable();
+        const args = ['install', '--prefix', stage, '--ignore-scripts', '--no-audit', '--no-fund', '--install-strategy=nested'];
+        const localArchive = path.isAbsolute(packageSpec) && fs.statSync(packageSpec, { throwIfNoEntry: false })?.isFile();
+        if (localArchive && process.env.VIGTHORIA_OFFLINE === '1')
+            args.push('--offline');
+        if (options.npmRegistry)
+            args.push(`--registry=${options.npmRegistry}`);
+        args.push(packageSpec);
+        if (!(localArchive && args.includes('--offline')))
+            assertProcessNetworkAllowed(npm, args);
+        execFileSync(npm, args, {
+            stdio: 'pipe',
+            windowsHide: true,
+            timeout: 180_000,
+            env: {
+                ...safeChildProcessEnv(),
+                npm_config_cache: path.join(cliRoot, '.npm-cache'),
+                npm_config_ignore_scripts: 'true',
+                npm_config_audit: 'false',
+                npm_config_fund: 'false',
+                npm_config_update_notifier: 'false',
+            },
+        });
+        smokeCandidate(stage, expectedVersion, homeDirectory);
+        fs.renameSync(stage, destination);
+        const currentStat = fs.lstatSync(currentLink, { throwIfNoEntry: false });
+        if (currentStat && !currentStat.isSymbolicLink())
+            throw new Error('Current release pointer is not a managed symbolic link; refusing to overwrite it.');
+        if (currentStat?.isSymbolicLink())
+            previousTarget = fs.readlinkSync(currentLink);
+        const temporaryLink = `${currentLink}.next-${randomUUID()}`;
+        fs.symlinkSync(destination, temporaryLink, process.platform === 'win32' ? 'junction' : 'dir');
+        try {
+            fs.renameSync(temporaryLink, currentLink);
+        }
+        catch (error) {
+            if (process.platform !== 'win32' || !fs.existsSync(currentLink))
+                throw error;
+            const backup = `${currentLink}.previous-${randomUUID()}`;
+            fs.renameSync(currentLink, backup);
+            try {
+                fs.renameSync(temporaryLink, currentLink);
+            }
+            catch (switchError) {
+                fs.renameSync(backup, currentLink);
+                throw switchError;
+            }
+            fs.rmSync(backup, { recursive: true, force: true });
+        }
+        switched = true;
+        writeLaunchers(binDirectory, currentLink);
+        return { version: expectedVersion, versionDirectory: destination, currentLink, previousTarget, binDirectory };
+    }
+    catch (error) {
+        if (switched) {
+            const rollbackLink = `${currentLink}.rollback-${randomUUID()}`;
+            try {
+                if (previousTarget) {
+                    fs.symlinkSync(previousTarget, rollbackLink, process.platform === 'win32' ? 'junction' : 'dir');
+                    fs.renameSync(rollbackLink, currentLink);
+                }
+                else {
+                    fs.unlinkSync(currentLink);
+                }
+                switched = false;
+            }
+            catch (rollbackError) {
+                const detail = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+                throw new Error(`Release activation failed and rollback failed: ${detail}`, { cause: error });
+            }
+            finally {
+                try {
+                    fs.unlinkSync(rollbackLink);
+                }
+                catch { }
+            }
+        }
+        if (!switched && fs.existsSync(destination))
+            fs.rmSync(destination, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        if (fs.existsSync(stage))
+            fs.rmSync(stage, { recursive: true, force: true });
+    }
+}

package/dist/utils/release-policy.d.ts

@@ -0,0 +1,64 @@
+export type ReleasePolicy = {
+    schemaVersion: number;
+    packageName: string;
+    manifest: {
+        schemaVersion: number;
+        maximumBytes: number;
+        requiredChannels: string[];
+        allowedChannels: string[];
+    };
+    origins: {
+        manifest: string;
+        artifacts: string;
+        allowedHosts: string[];
+        port: number;
+        maximumRedirects: number;
+    };
+    artifact: {
+        maximumBytes: number;
+        filenamePattern: string;
+    };
+    signature: {
+        algorithm: 'Ed25519';
+        trustedKeys: Record<string, string>;
+    };
+    channels: Record<string, {
+        allowPrerelease: boolean;
+        allowDowngrade: boolean;
+    }>;
+    installation: {
+        versionsDirectory: string;
+        currentLink: string;
+        binDirectory: string;
+        preservePrevious: number;
+    };
+};
+export type ReleaseEvidence = {
+    url: string;
+    sha256: string;
+};
+export type ReleaseManifestEntry = {
+    version: string;
+    url: string;
+    sha256: string;
+    size: number;
+    archiveFilename: string;
+    packageName: string;
+    packageVersion: string;
+    publishedAt: string;
+    signature: {
+        algorithm: 'Ed25519';
+        keyId: string;
+        url: string;
+    };
+    sbom: ReleaseEvidence;
+    provenance: ReleaseEvidence;
+    notes?: string;
+};
+export declare function getReleasePolicy(): ReleasePolicy;
+export declare function assertReleaseUrl(raw: unknown, kind?: 'manifest' | 'artifact' | 'signature' | 'evidence'): URL;
+export declare function parseReleaseManifest(input: unknown, channel?: string, serializedBytes?: number): ReleaseManifestEntry;
+export declare function parseReleaseManifestText(text: string, channel?: string): ReleaseManifestEntry;
+export declare function releaseSignaturePayload(channel: string, entry: ReleaseManifestEntry): Buffer;
+export declare function verifyReleaseSignature(channel: string, entry: ReleaseManifestEntry, detachedBase64: string, trustedKeys?: Record<string, string>): void;
+export declare function assertReleaseTransition(currentVersion: string, entry: ReleaseManifestEntry, channel: string, allowDowngrade?: boolean): void;