vigthoria-cli 1.13.23 → 1.13.25

package/dist/utils/local-security-service.js

@@ -0,0 +1,210 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { isSensitivePath } from './secret-policy.js';
+import { WorkspaceBoundaryError } from './workspace-boundary.js';
+const MAX_FILES = 5_000;
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const SCANNABLE_EXTENSIONS = new Set([
+    '.cjs', '.css', '.go', '.html', '.htm', '.java', '.js', '.jsx', '.json',
+    '.mjs', '.php', '.ps1', '.py', '.rb', '.sh', '.sql', '.ts', '.tsx',
+    '.vue', '.xml', '.yaml', '.yml',
+]);
+const EXCLUDED_DIRECTORIES = new Set([
+    '.git', '.hg', '.svn', '.vigthoria', 'build', 'coverage', 'dist',
+    'node_modules', 'target', 'vendor', '__pycache__', '.venv', 'venv',
+]);
+// These are intentionally high-confidence source patterns. The scanner does
+// not classify ordinary bind addresses, DOM APIs, or configuration examples as
+// vulnerabilities without the context required to prove exploitability.
+const RULES = [
+    {
+        id: 'hardcoded-private-key',
+        severity: 'critical',
+        expression: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g,
+        message: 'Private key material is embedded in source',
+    },
+    {
+        id: 'hardcoded-access-token',
+        severity: 'critical',
+        expression: /\b(?:ghp|gho|ghu|ghs|github_pat|xox[baprs])_[A-Za-z0-9_-]{20,}\b/g,
+        message: 'A high-confidence access token is embedded in source',
+    },
+    {
+        id: 'hardcoded-cloud-key',
+        severity: 'critical',
+        expression: /\bAKIA[0-9A-Z]{16}\b/g,
+        message: 'An AWS access key identifier is embedded in source',
+    },
+    {
+        id: 'child-process-shell',
+        severity: 'high',
+        expression: /\b(?:exec|execSync)\s*\(\s*(?:`|[^'"\s][^,\n]*)/g,
+        message: 'A child process appears to execute dynamically constructed shell text',
+    },
+    {
+        id: 'dynamic-code-evaluation',
+        severity: 'high',
+        expression: /\b(?:eval|Function)\s*\(\s*(?!['"](?:use strict)?['"])/g,
+        message: 'Dynamic code evaluation requires manual security review',
+    },
+    {
+        id: 'unsafe-tls-disable',
+        severity: 'high',
+        expression: /\b(?:NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*['"]?0|rejectUnauthorized\s*:\s*false)\b/g,
+        message: 'TLS certificate validation is explicitly disabled',
+    },
+];
+function assertScanRoot(input) {
+    const resolved = path.resolve(input || process.cwd());
+    if (process.platform === 'win32' && /^(?:\\\\[?.]\\|\\\\(?!localhost\\))/i.test(resolved)) {
+        throw new WorkspaceBoundaryError('UNC and Windows device paths are not valid security scan roots', 'UNSAFE_WINDOWS_PATH');
+    }
+    const stat = fs.lstatSync(resolved);
+    if (stat.isSymbolicLink()) {
+        throw new WorkspaceBoundaryError('A symbolic link or junction cannot be used as a security scan root', 'WORKSPACE_LINK_ESCAPE');
+    }
+    if (!stat.isDirectory())
+        throw new WorkspaceBoundaryError('Security scan root must be a directory', 'WORKSPACE_PATH_INVALID');
+    return fs.realpathSync(resolved);
+}
+function stableIssueId(rule, file, line) {
+    return `SEC-${createHash('sha256').update(`${rule}\0${file}\0${line}`).digest('hex').slice(0, 12).toUpperCase()}`;
+}
+function lineAt(content, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index += 1)
+        if (content.charCodeAt(index) === 10)
+            line += 1;
+    return line;
+}
+function scoreFromIssues(issues) {
+    const penalty = { critical: 20, high: 10, medium: 4, low: 1 };
+    return Math.max(0, 100 - issues.reduce((sum, issue) => sum + penalty[issue.severity], 0));
+}
+function gradeFromScore(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 75)
+        return 'B';
+    if (score >= 50)
+        return 'C';
+    if (score >= 30)
+        return 'D';
+    return 'F';
+}
+export function scanLocalWorkspace(inputRoot = process.cwd()) {
+    const rootDir = assertScanRoot(inputRoot);
+    const stack = [rootDir];
+    const issues = [];
+    let scannedFiles = 0;
+    let scannedBytes = 0;
+    let skippedFiles = 0;
+    while (stack.length > 0) {
+        const directory = stack.pop();
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolute = path.join(directory, entry.name);
+            const relative = path.relative(rootDir, absolute).split(path.sep).join('/');
+            if (entry.isSymbolicLink()) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRECTORIES.has(entry.name) && !isSensitivePath(relative))
+                    stack.push(absolute);
+                continue;
+            }
+            if (!entry.isFile()) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (isSensitivePath(relative)) {
+                const basename = path.basename(relative).toLowerCase();
+                if (basename === '.env' || basename.startsWith('.env.')) {
+                    issues.push({
+                        id: stableIssueId('sensitive-env-file', relative, 1),
+                        rule: 'sensitive-env-file',
+                        severity: 'medium',
+                        file: relative,
+                        line: 1,
+                        message: 'Sensitive environment file exists in the scanned tree; verify it is excluded from version control and uploads',
+                    });
+                }
+                skippedFiles += 1;
+                continue;
+            }
+            if (!SCANNABLE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
+                continue;
+            if (scannedFiles >= MAX_FILES)
+                throw new Error(`Security scan file limit exceeded (${MAX_FILES})`);
+            const stat = fs.statSync(absolute);
+            if (stat.size > MAX_FILE_BYTES) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (scannedBytes + stat.size > MAX_TOTAL_BYTES)
+                throw new Error(`Security scan byte limit exceeded (${MAX_TOTAL_BYTES})`);
+            const content = fs.readFileSync(absolute, 'utf8');
+            scannedFiles += 1;
+            scannedBytes += stat.size;
+            for (const rule of RULES) {
+                rule.expression.lastIndex = 0;
+                let match;
+                while ((match = rule.expression.exec(content)) !== null) {
+                    const line = lineAt(content, match.index);
+                    issues.push({
+                        id: stableIssueId(rule.id, relative, line),
+                        rule: rule.id,
+                        severity: rule.severity,
+                        file: relative,
+                        line,
+                        message: rule.message,
+                    });
+                    if (match[0].length === 0)
+                        rule.expression.lastIndex += 1;
+                }
+            }
+        }
+    }
+    issues.sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.rule.localeCompare(right.rule));
+    const score = scoreFromIssues(issues);
+    return {
+        rootDir,
+        scannedFiles,
+        scannedBytes,
+        skippedFiles,
+        score,
+        grade: gradeFromScore(score),
+        issueCount: issues.length,
+        issues,
+        bounded: true,
+        localOnly: true,
+    };
+}
+export function localSecurityFixPlan(result, issueId, requestedApply = false) {
+    const selected = issueId ? result.issues.filter((issue) => issue.id === issueId) : result.issues;
+    if (issueId && selected.length === 0)
+        throw new Error(`Security issue was not found in the current scan: ${issueId}`);
+    const actions = selected.slice(0, 100).map((issue) => ({
+        issue_id: issue.id,
+        file: issue.file,
+        line: issue.line,
+        rule: issue.rule,
+        action: issue.rule === 'sensitive-env-file'
+            ? 'Confirm the file is ignored and excluded from every upload/context boundary; rotate any exposed values'
+            : 'Review the exact source location and replace the unsafe construct without weakening validation or trust boundaries',
+    }));
+    return {
+        success: true,
+        applied: false,
+        requestedApply,
+        confirmRequired: false,
+        plannedActions: actions,
+        message: requestedApply
+            ? 'No mutation was performed: local security fixes require an explicit reviewed source patch.'
+            : 'Local security fix plan generated; no files were changed.',
+        localOnly: true,
+    };
+}

package/dist/utils/model-transport-service.js

@@ -1,4 +1,4 @@
-import { scanOutboundContext } from './secret-policy.js';
+import { redactSensitiveText, scanOutboundContext } from './secret-policy.js';
 export class ModelTransportService {
     dependencies;
     lastErrors = [];
@@ -28,15 +28,75 @@ export class ModelTransportService {
     }
     async complete(systemPrompt, userPrompt, model, maxTokens) {
         const resolvedModel = model ? this.dependencies.resolvePermittedModelId(model) : 'Vigthoria-v4-Code-27B';
-        const response = await this.dependencies.postModels({
+        const messages = scanOutboundContext([{ role: 'system', content: systemPrompt }, { role: 'user', content: userPrompt }]).value;
+        const body = {
             model: resolvedModel,
-            messages: scanOutboundContext([{ role: 'system', content: systemPrompt }, { role: 'user', content: userPrompt }]).value,
+            messages,
             max_tokens: maxTokens || this.dependencies.getMaxTokens() || 4096,
             temperature: 0.3,
             stream: false,
-        });
-        const content = response?.choices?.[0]?.message?.content || response?.choices?.[0]?.text || '';
-        return typeof content === 'string' ? content : '';
+        };
+        const failures = [];
+        const safeFailure = (value) => redactSensitiveText(String(value || 'transport failed')).slice(0, 120);
+        const extract = (response) => {
+            const content = response?.choices?.[0]?.message?.content
+                || response?.choices?.[0]?.text
+                || response?.response
+                || response?.message
+                || response?.content;
+            return response?.success === false || typeof content !== 'string' ? '' : content.trim();
+        };
+        if (!this.dependencies.shouldSkipCloudRoutes(resolvedModel) && !this.dependencies.isCloudModelId(resolvedModel)) {
+            try {
+                const content = extract(await this.dependencies.postModels(body));
+                if (content)
+                    return content;
+                failures.push('models:empty response');
+            }
+            catch (error) {
+                failures.push(`models:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+        }
+        if (this.dependencies.isAuthenticated() && !this.dependencies.shouldSkipCloudRoutes(resolvedModel)) {
+            const coderBody = {
+                messages,
+                model: resolvedModel,
+                maxTokens: body.max_tokens,
+                temperature: body.temperature,
+                cloudConsent: this.dependencies.isCloudModelId(resolvedModel),
+            };
+            try {
+                const content = extract(await this.dependencies.postCoder(coderBody));
+                if (content)
+                    return content;
+                failures.push('coder:empty response');
+            }
+            catch (error) {
+                failures.push(`coder:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+            try {
+                const content = extract(await this.dependencies.postCanonicalCoder(coderBody));
+                if (content)
+                    return content;
+                failures.push('coder-canonical:empty response');
+            }
+            catch (error) {
+                failures.push(`coder-canonical:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+        }
+        if (this.dependencies.hasSelfHostedTransport() && this.dependencies.shouldTrySelfHosted(resolvedModel, model || resolvedModel)) {
+            try {
+                const content = extract(await this.dependencies.postSelfHosted(body));
+                if (content)
+                    return content;
+                failures.push('self-hosted:empty response');
+            }
+            catch (error) {
+                failures.push(`self-hosted:${safeFailure(error?.message)}`);
+            }
+        }
+        this.lastErrors = failures;
+        throw new Error(`No permitted code-completion backend returned a response${failures.length ? ` (${failures.join(' | ')})` : ''}.`);
     }
     response(data, model, requested, prefix) {
         const content = data?.choices?.[0]?.message?.content || data?.choices?.[0]?.text || data?.response || data?.message || data?.content;

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

@@ -1,6 +1,6 @@
 import type { AxiosInstance } from 'axios';
 export { redactSensitiveText } from './secret-policy.js';
-export type EndpointAudience = 'auto' | 'coder' | 'models' | 'hub' | 'community' | 'music' | 'brain-hub' | 'mcp' | 'v3' | 'template' | 'hyperloop' | 'vigflow' | 'bridge' | 'release' | 'public';
+export type EndpointAudience = 'auto' | 'coder' | 'models' | 'operator' | 'hub' | 'community' | 'music' | 'brain-hub' | 'mcp' | 'v3' | 'template' | 'hyperloop' | 'vigflow' | 'bridge' | 'release' | 'public';
 export declare const DEFAULT_NETWORK_TIMEOUT_MS = 30000;
 export declare class NetworkPolicyError extends Error {
     readonly code: 'offline' | 'untrusted_endpoint' | 'credential_audience' | 'unsafe_redirect';

package/dist/utils/network-policy.js

@@ -3,7 +3,8 @@ export { redactSensitiveText } from './secret-policy.js';
 const AUDIENCE_HOSTS = {
     coder: new Set(['coder.vigthoria.io']),
     models: new Set(['api.vigthoria.io']),
-    hub: new Set(['api.vigthoria.io']),
+    operator: new Set(['api.vigthoria.io', 'operator.vigthoria.io']),
+    hub: new Set(['hub.vigthoria.io']),
     community: new Set(['community.vigthoria.io']),
     music: new Set(['music.vigthoria.io']),
     'brain-hub': new Set(['coder.vigthoria.io']),
@@ -11,7 +12,7 @@ const AUDIENCE_HOSTS = {
     v3: new Set(['coder.vigthoria.io']),
     template: new Set(['coder.vigthoria.io', 'template.vigthoria.io']),
     hyperloop: new Set(['coder.vigthoria.io', 'hyperloop.vigthoria.io']),
-    vigflow: new Set(['coder.vigthoria.io', 'vigflow.vigthoria.io']),
+    vigflow: new Set(['coder.vigthoria.io', 'workflow.vigthoria.io']),
     bridge: new Set(['bridge.vigthoria.io', 'devtools.vigthoria.io']),
     release: new Set([
         'extension.vigthoria.io',

package/dist/utils/preview-screenshot-adapter.js

@@ -20,12 +20,12 @@ export class OptionalPuppeteerScreenshotAdapter {
             const loaded = await this.loadPuppeteer().catch(() => null);
             const puppeteer = (loaded?.default || loaded);
             if (!puppeteer || typeof puppeteer.launch !== 'function') {
-                return { captured: false, error: 'puppeteer optional adapter is not installed' };
+                return { captured: false, error: 'required Puppeteer screenshot runtime is not installed' };
             }
             const browserProfile = this.allocateTemp('browser-');
             try {
                 const browser = await puppeteer.launch({
-                    headless: true,
+                    headless: 'shell',
                     args: ['--no-sandbox', '--disable-setuid-sandbox'],
                     userDataDir: browserProfile,
                 });

package/dist/utils/secret-policy.js

@@ -104,7 +104,10 @@ export function installConsoleRedaction() {
 }
 export function scanOutboundContext(input) {
     const findings = new Set();
-    const seen = new WeakSet();
+    // Track only the active recursion path. A WeakSet of every previously seen
+    // object incorrectly rejects ordinary DAGs where compatibility aliases point
+    // at the same context object. Only an ancestor reference is a real cycle.
+    const ancestors = new WeakSet();
     const visit = (value, location, depth) => {
         if (depth > 24)
             throw new OutboundContextError([`${location}: depth limit exceeded`]);
@@ -119,26 +122,32 @@ export function scanOutboundContext(input) {
         }
         if (!value || typeof value !== 'object')
             return value;
-        if (seen.has(value))
+        const objectValue = value;
+        if (ancestors.has(objectValue))
             throw new OutboundContextError([`${location}: cyclic value`]);
-        seen.add(value);
-        if (Array.isArray(value))
-            return value.map((entry, index) => visit(entry, `${location}[${index}]`, depth + 1));
-        const output = {};
-        for (const [key, entry] of Object.entries(value)) {
-            const child = `${location}.${key}`;
-            if (isSensitivePath(key)) {
-                findings.add(`${child}: sensitive path excluded`);
-                continue;
+        ancestors.add(objectValue);
+        try {
+            if (Array.isArray(value))
+                return value.map((entry, index) => visit(entry, `${location}[${index}]`, depth + 1));
+            const output = {};
+            for (const [key, entry] of Object.entries(value)) {
+                const child = `${location}.${key}`;
+                if (isSensitivePath(key)) {
+                    findings.add(`${child}: sensitive path excluded`);
+                    continue;
+                }
+                if (SENSITIVE_KEY.test(key)) {
+                    findings.add(`${child}: credential field redacted`);
+                    output[key] = REDACTED;
+                    continue;
+                }
+                output[key] = visit(entry, child, depth + 1);
             }
-            if (SENSITIVE_KEY.test(key)) {
-                findings.add(`${child}: credential field redacted`);
-                output[key] = REDACTED;
-                continue;
-            }
-            output[key] = visit(entry, child, depth + 1);
+            return output;
+        }
+        finally {
+            ancestors.delete(objectValue);
         }
-        return output;
     };
     const value = visit(input, '$', 0);
     if (containsHighConfidenceSecret(JSON.stringify(value))) {

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

@@ -0,0 +1,11 @@
+export interface NormalizedSubscription {
+    plan: string;
+    status: string;
+    expiresAt?: string;
+}
+/**
+ * Normalize the subscription shapes emitted by the Coder, User Hub, and
+ * legacy authentication contracts. Missing plan data is never synthesized:
+ * callers must retain their prior authoritative value or fail closed.
+ */
+export declare function normalizeSubscriptionResponse(payload: unknown): NormalizedSubscription | null;

package/dist/utils/subscription-policy.js

@@ -0,0 +1,32 @@
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+/**
+ * Normalize the subscription shapes emitted by the Coder, User Hub, and
+ * legacy authentication contracts. Missing plan data is never synthesized:
+ * callers must retain their prior authoritative value or fail closed.
+ */
+export function normalizeSubscriptionResponse(payload) {
+    const body = record(payload);
+    const subscription = record(body.subscription);
+    const user = record(body.user);
+    const userSubscription = record(user.subscription);
+    const plan = firstString(body.plan, body.subscription_plan, body.subscriptionPlan, body.subscriptionTier, body.tier, subscription.plan, subscription.name, subscription.subscription_plan, subscription.subscriptionPlan, subscription.subscriptionTier, subscription.tier, user.plan, user.subscription_plan, user.subscriptionPlan, user.subscriptionTier, user.tier, userSubscription.plan, userSubscription.name, userSubscription.subscription_plan, userSubscription.subscriptionPlan, userSubscription.subscriptionTier, userSubscription.tier);
+    if (!plan)
+        return null;
+    const explicitStatus = firstString(body.status, body.subscription_status, body.subscriptionStatus, subscription.status, subscription.subscription_status, subscription.subscriptionStatus, user.status, user.subscription_status, user.subscriptionStatus, userSubscription.status, userSubscription.subscription_status, userSubscription.subscriptionStatus);
+    const activeFlag = [body.active, subscription.active, user.active, userSubscription.active]
+        .find((value) => typeof value === 'boolean');
+    const status = explicitStatus || (activeFlag === false ? 'inactive' : 'active');
+    const expiresAt = firstString(body.expiresAt, body.expires_at, subscription.expiresAt, subscription.expires_at, user.expiresAt, user.expires_at, userSubscription.expiresAt, userSubscription.expires_at);
+    return { plan, status: status.toLowerCase(), ...(expiresAt ? { expiresAt } : {}) };
+}

package/dist/utils/v3-workspace-service.js

@@ -135,7 +135,11 @@ export class V3WorkspaceService {
         const candidates = new Set();
         for (const value of [message, context.rawMessage, context.agentPrompt]) {
             const text = String(value || '');
-            for (const pattern of [/`([^`]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))`/gi, /\b([A-Za-z0-9_./-]+\.(?:html|css|js|jsx|ts|tsx|json|md|py|sh))\b/g]) {
+            const extensions = 'c|cc|cpp|cxx|h|hpp|cs|css|go|html|htm|ini|java|js|jsx|json|kt|kts|md|mjs|cjs|php|ps1|py|rb|rs|scss|sh|sql|svelte|toml|ts|tsx|txt|vue|xml|yaml|yml';
+            for (const pattern of [
+                new RegExp('`([^`]+\\.(?:' + extensions + '))`', 'gi'),
+                new RegExp('\\b([A-Za-z0-9_./-]+\\.(?:' + extensions + '))\\b', 'gi'),
+            ]) {
                 let match;
                 while ((match = pattern.exec(text)) !== null) {
                     const filePath = match[1].trim().replace(/^\.\//, '');

package/dist/utils/vigflow-client.js

@@ -16,8 +16,8 @@ export class VigFlowClient {
         const authToken = this.dependencies.getAccessToken();
         if (!authToken)
             throw new Error('Not authenticated. Run vigthoria login first.');
-        const response = await this.transport.post(`${baseUrl}/api/auth/sso`, { token: authToken }, {
-            headers: { 'Content-Type': 'application/json' }, timeout: 30_000,
+        const response = await this.transport.post(`${baseUrl}/api/auth/sso`, {}, {
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${authToken}` }, timeout: 30_000,
         });
         const token = String(response.data.token || '').trim();
         if (!token)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.13.23",
+  "version": "1.13.25",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -93,7 +93,7 @@
     "test:pitfall:context": "npm run build && node scripts/test-pitfall-context-smoke.js",
     "test:game:command": "node scripts/test-game-command.mjs",
     "test:security:dependencies": "node scripts/test-dependency-security.mjs",
-    "test:security:network": "npm run build && node scripts/test-network-policy.mjs && node scripts/test-installer-trust-policy.mjs",
+    "test:security:network": "npm run build && node scripts/test-network-policy.mjs && node scripts/test-installer-trust-policy.mjs && node scripts/test-local-security-service.mjs",
     "test:security:workspace": "npm run build && node scripts/test-workspace-archive-containment.mjs",
     "test:security:process": "npm run build && node scripts/test-process-approval-safety.mjs",
     "test:security:mutation-preview": "npm run build && node scripts/test-mutation-preview-transaction.mjs",
@@ -131,6 +131,7 @@
     "marked": "^11.0.0",
     "marked-terminal": "^6.2.0",
     "ora": "^7.0.1",
+    "puppeteer": "^24.40.0",
     "ws": "^8.14.2"
   },
   "devDependencies": {
@@ -138,18 +139,9 @@
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.10.0",
     "@types/ws": "^8.5.10",
-    "puppeteer": "^24.40.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.2"
   },
-  "peerDependencies": {
-    "puppeteer": "^24.40.0"
-  },
-  "peerDependenciesMeta": {
-    "puppeteer": {
-      "optional": true
-    }
-  },
   "engines": {
     "node": ">=20.19.0"
   },

package/release-policy.json

@@ -27,7 +27,8 @@
   "signature": {
     "algorithm": "Ed25519",
     "trustedKeys": {
-      "vigthoria-release-2026-01": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAotTXdcHwZ+D1z5lJMdgAAeMU99BRdMCaCZ465DN2aug=\n-----END PUBLIC KEY-----\n"
+      "vigthoria-release-2026-01": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAotTXdcHwZ+D1z5lJMdgAAeMU99BRdMCaCZ465DN2aug=\n-----END PUBLIC KEY-----\n",
+      "vigthoria-release-2026-02": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAwzjKsJCJhF387ZPbQoGTciJtOLyJFXp4zpOKrrhQm8I=\n-----END PUBLIC KEY-----\n"
     }
   },
   "channels": {

package/scripts/release/generate-release-evidence.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+
+const archive = path.resolve(String(process.argv[2] || ''));
+const outputDirectory = path.resolve(String(process.argv[3] || ''));
+if (!fs.statSync(archive, { throwIfNoEntry: false })?.isFile()) throw new Error('Usage: generate-release-evidence.mjs <archive.tgz> <output-directory>');
+fs.mkdirSync(outputDirectory, { recursive: true });
+const sha256 = createHash('sha256').update(fs.readFileSync(archive)).digest('hex');
+const readPackage = spawnSync('tar', ['-xOf', archive, 'package/package.json'], { encoding: 'utf8', maxBuffer: 1024 * 1024 });
+if (readPackage.status !== 0) throw new Error(`Unable to inspect archive: ${readPackage.stderr || readPackage.stdout}`);
+const pkg = JSON.parse(readPackage.stdout);
+if (pkg.name !== 'vigthoria-cli' || !pkg.version) throw new Error('Archive package identity is invalid');
+const timestamp = new Date().toISOString();
+const component = {
+  type: 'application',
+  'bom-ref': `pkg:npm/${pkg.name}@${pkg.version}`,
+  name: pkg.name,
+  version: pkg.version,
+  purl: `pkg:npm/${pkg.name}@${pkg.version}`,
+  hashes: [{ alg: 'SHA-256', content: sha256 }],
+};
+const components = Object.entries(pkg.dependencies || {}).sort(([left], [right]) => left.localeCompare(right)).map(([name, version]) => ({
+  type: 'library', name, version: String(version), purl: `pkg:npm/${encodeURIComponent(name)}@${encodeURIComponent(String(version))}`,
+  scope: 'required',
+}));
+const sbom = {
+  bomFormat: 'CycloneDX', specVersion: '1.5', serialNumber: `urn:uuid:${randomUUID()}`, version: 1,
+  metadata: { timestamp, tools: { components: [{ type: 'application', name: 'vigthoria-cli-release-evidence', version: '1' }] }, component },
+  components,
+};
+const provenance = {
+  _type: 'https://in-toto.io/Statement/v1',
+  subject: [{ name: path.basename(archive), digest: { sha256 } }],
+  predicateType: 'https://vigthoria.io/provenance/verified-existing-artifact/v1',
+  predicate: {
+    package: { name: pkg.name, version: pkg.version },
+    verification: { method: 'sha256-and-embedded-package-identity', verifiedAt: timestamp },
+    claimBoundary: 'This record verifies an existing immutable artifact; it does not reconstruct or attest to its original build environment.',
+  },
+};
+const stem = `${pkg.name}-${pkg.version}.tgz`;
+const sbomPath = path.join(outputDirectory, `${stem}.sbom.json`);
+const provenancePath = path.join(outputDirectory, `${stem}.provenance.json`);
+fs.writeFileSync(sbomPath, `${JSON.stringify(sbom, null, 2)}\n`, { mode: 0o644 });
+fs.writeFileSync(provenancePath, `${JSON.stringify(provenance, null, 2)}\n`, { mode: 0o644 });
+console.log(JSON.stringify({ packageName: pkg.name, version: pkg.version, sha256, size: fs.statSync(archive).size, sbomPath, provenancePath }, null, 2));

package/scripts/release/publish-cli-release.mjs

@@ -20,6 +20,9 @@ const privateKeyFile = String(process.env.RELEASE_SIGNING_PRIVATE_KEY_FILE || ''
 const keyId = String(process.env.RELEASE_SIGNING_KEY_ID || '');
 const sbomFile = String(process.env.RELEASE_SBOM_FILE || '');
 const provenanceFile = String(process.env.RELEASE_PROVENANCE_FILE || '');
+const externalArchive = String(process.env.RELEASE_ARCHIVE_FILE || '');
+const republishExisting = process.env.RELEASE_REPUBLISH_EXISTING === '1';
+const resetManifest = process.env.RELEASE_RESET_MANIFEST === '1';
 const policy = getReleasePolicy();
 
 function stop(message) { throw new Error(message); }
@@ -41,14 +44,17 @@ requiredFile(sbomFile, 'RELEASE_SBOM_FILE');
 requiredFile(provenanceFile, 'RELEASE_PROVENANCE_FILE');
 if (!Object.hasOwn(policy.signature.trustedKeys, keyId)) stop(`RELEASE_SIGNING_KEY_ID is not trusted by release-policy.json: ${keyId || '(unset)'}`);
 
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
-if ([pkg.version, lock.version, lock.packages?.['']?.version].some((identity) => identity !== version)) stop('Requested version conflicts with package.json or package-lock.json.');
-const runtime = spawnSync(process.execPath, ['dist/index.js', '--version'], { cwd: root, encoding: 'utf8', env: { ...process.env, VIGTHORIA_OFFLINE: '1', VIGTHORIA_NO_BANNER: '1' } });
-if (runtime.status !== 0 || runtime.stdout.trim() !== version) stop('Requested version conflicts with the built CLI banner.');
+if (externalArchive && !republishExisting) stop('RELEASE_ARCHIVE_FILE requires RELEASE_REPUBLISH_EXISTING=1.');
+if (!externalArchive) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
+  if ([pkg.version, lock.version, lock.packages?.['']?.version].some((identity) => identity !== version)) stop('Requested version conflicts with package.json or package-lock.json.');
+  const runtime = spawnSync(process.execPath, ['dist/index.js', '--version'], { cwd: root, encoding: 'utf8', env: { ...process.env, VIGTHORIA_OFFLINE: '1', VIGTHORIA_NO_BANNER: '1' } });
+  if (runtime.status !== 0 || runtime.stdout.trim() !== version) stop('Requested version conflicts with the built CLI banner.');
+}
 
 const archiveFilename = `${policy.packageName}-${version}.tgz`;
-const archive = path.join(root, archiveFilename);
+const archive = externalArchive ? path.resolve(externalArchive) : path.join(root, archiveFilename);
 requiredFile(archive, 'Release archive');
 const metadata = exactPackageMetadata(archive);
 if (metadata.name !== policy.packageName || metadata.version !== version) stop('Requested version conflicts with archive metadata.');
@@ -87,16 +93,21 @@ try {
   verifyReleaseSignature(channel, entry, detached);
 
   let manifest = { schemaVersion: policy.manifest.schemaVersion, channels: {} };
-  if (fs.existsSync(manifestFile)) manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+  if (!resetManifest && fs.existsSync(manifestFile)) manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
   manifest.channels = { ...manifest.channels, [channel]: entry };
   parseReleaseManifest(manifest, channel);
 
   const inputs = [[archive, archiveFilename], [sbomFile, sbomFilename], [provenanceFile, provenanceFilename]];
   const staged = [];
   for (const [source, filename] of inputs) {
+    const destination = path.join(downloadsDirectory, filename);
+    if (fs.existsSync(destination)) {
+      if (republishExisting && digest(destination) === digest(source) && fs.statSync(destination).size === fs.statSync(source).size) continue;
+      stop(`Refusing to overwrite published release component: ${destination}`);
+    }
     const temporary = path.join(downloadsDirectory, `.${filename}.${suffix}.tmp`);
     fs.copyFileSync(source, temporary, fs.constants.COPYFILE_EXCL);
-    staged.push([temporary, path.join(downloadsDirectory, filename)]);
+    staged.push([temporary, destination]);
   }
   const signatureTemporary = path.join(downloadsDirectory, `.${signatureFilename}.${suffix}.tmp`);
   fs.writeFileSync(signatureTemporary, `${detached}\n`, { flag: 'wx', mode: 0o644 });