@wrongstack/core 0.280.0 → 0.281.0

package/dist/{permission-policy-C8vJcnX5.d.ts → secret-vault-D7jeyXUQ.d.ts}

@@ -1,6 +1,9 @@
-import { T as Tool, C as Context } from './tool-BkOgs_KL.js';
+import { g as Tool, d as Context } from './tool-LVSLiE1s.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { P as PermissionPolicy, a as PermissionDecision } from './permission-Dx6dIqS2.js';
+import { P as PermissionPolicy, a as PermissionDecision } from './permission-B6YAtNFz.js';
+import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
+import { L as Logger } from './logger-B63L5bTg.js';
+import { R as RotatableSecretVault, S as SecretVault } from './secret-vault-BAKpgFw_.js';
 
 interface PermissionPolicyOptions {
     trustFile: string;
@@ -152,4 +155,117 @@ declare class AutoApprovePermissionPolicy implements PermissionPolicy {
     reload(): Promise<void>;
 }
 
-export { AutoApprovePermissionPolicy as A, DefaultPermissionPolicy as D, type PermissionPolicyOptions as P };
+declare class DefaultSecretScrubber implements SecretScrubber {
+    scrub(text: string): string;
+    private scrubOne;
+    /**
+     * Recursively scrub every string value in an object/array graph. Secrets can
+     * appear under any key — a URL query param, an `authorization` header, an
+     * arbitrarily-named nested field — so we don't gate recursion on key names.
+     * The per-string `scrub()` fast-path (anchor pre-scan) keeps this cheap: any
+     * value without a credential anchor returns immediately without regex work.
+     */
+    scrubObject<T>(obj: T): T;
+}
+
+interface SecretVaultOptions {
+    /** Absolute path to the key file. Created with mode 0o600 if missing. */
+    keyFile: string;
+}
+/**
+ * Default vault: AES-256-GCM with a key stored at `keyFile` (mode 0o600).
+ * The key is loaded lazily on first encrypt/decrypt; if it does not exist,
+ * a fresh one is generated. Decryption of plaintext values is a no-op so
+ * legacy configs continue to work.
+ *
+ * Key file format:
+ *   - Legacy (v1): exactly 32 raw bytes
+ *   - Versioned (v2+): 4-byte magic `WSKV` + 1-byte version + 32-byte key (37 bytes)
+ *
+ * Encrypted value format: `enc:v<N>:<iv>:<tag>:<ciphertext>` where N is the
+ * key version. After rotation, encrypt() emits the new version prefix.
+ */
+declare class DefaultSecretVault implements RotatableSecretVault {
+    private readonly keyFile;
+    private key?;
+    private _keyVersion;
+    constructor(opts: SecretVaultOptions);
+    /** Current key version. Starts at 1; incremented by rotateKey(). */
+    get keyVersion(): number;
+    isEncrypted(value: string): boolean;
+    encrypt(plaintext: string): string;
+    decrypt(value: string): string;
+    /**
+     * Generate a new encryption key, write it to disk, and increment the key version.
+     * After rotation, encrypt() emits the new version prefix (e.g. enc:v2:).
+     * The caller must re-encrypt existing config values (see rotateConfigKeys()).
+     */
+    rotateKey(): {
+        oldVersion: number;
+        newVersion: number;
+    };
+    /**
+     * If WRONGSTACK_VAULT_PASSPHRASE is set but the key on disk is still stored
+     * unwrapped (legacy v1 / versioned v2), re-write it in passphrase-wrapped (v3)
+     * form. The data key is preserved, so all existing ciphertext keeps
+     * decrypting. Best-effort: a write failure leaves the working unwrapped file
+     * in place and is not fatal to load.
+     */
+    private migrateToWrappedIfPassphrase;
+    private loadOrCreateKey;
+}
+/**
+ * Walk a Config-shaped object and decrypt any apiKey-like fields in place,
+ * returning a new object. Used by the config loader so the rest of the
+ * system never has to know about the wire format.
+ *
+ * @param warn — callback for decryption warnings. Defaults to `console.warn`
+ *   for backward compatibility; pass `logger.warn` when a structured logger
+ *   is available (preferred in long-running/server contexts).
+ */
+declare function decryptConfigSecrets<T>(cfg: T, vault: SecretVault, opts?: {
+    warn?: (msg: string) => void;
+}): T;
+declare function encryptConfigSecrets<T>(cfg: T, vault: SecretVault, _opts?: {
+    warn?: (msg: string) => void;
+}): T;
+declare function isSecretField(name: string): boolean;
+/**
+ * Re-write `~/.wrongstack/config.json` (or any path) with all secret-bearing
+ * fields encrypted. Used by the `wstack auth` subcommand.
+ */
+declare function rewriteConfigEncrypted(configPath: string, vault: SecretVault, patch?: Record<string, unknown>): Promise<void>;
+/**
+ * Scan a config file on disk for plaintext secret-bearing fields and
+ * rewrite the file with them encrypted in place. Returns a count of how
+ * many fields were migrated. Idempotent — calling on a fully-encrypted
+ * file is a no-op and writes nothing. Used by the CLI on every boot so
+ * users who had plaintext keys before the vault landed are upgraded
+ * transparently.
+ */
+declare function migratePlaintextSecrets(configPath: string, vault: SecretVault, logger?: Pick<Logger, 'warn'>): Promise<{
+    migrated: number;
+    file: string;
+}>;
+/**
+ * Rotate the vault's encryption key and re-encrypt all secret-bearing
+ * fields in a config file. This is the atomic key rotation operation:
+ *
+ * 1. Read the config file
+ * 2. Decrypt all encrypted values with the old key
+ * 3. Generate a new key (vault.rotateKey())
+ * 4. Re-encrypt all values with the new key (new version prefix)
+ * 5. Write the config file atomically
+ *
+ * Returns the number of fields re-encrypted and the version transition.
+ * If the config file doesn't exist or has no encrypted fields, returns
+ * { rotated: 0 } without modifying the key.
+ */
+declare function rotateConfigKeys(configPath: string, vault: RotatableSecretVault, logger?: Pick<Logger, 'warn' | 'info'>): Promise<{
+    rotated: number;
+    oldVersion: number;
+    newVersion: number;
+    file: string;
+}>;
+
+export { AutoApprovePermissionPolicy as A, DefaultSecretVault as D, type PermissionPolicyOptions as P, type SecretVaultOptions as S, DefaultPermissionPolicy as a, DefaultSecretScrubber as b, rotateConfigKeys as c, decryptConfigSecrets as d, encryptConfigSecrets as e, isSecretField as i, migratePlaintextSecrets as m, rewriteConfigEncrypted as r };

package/dist/security/index.d.ts

@@ -1,9 +1,8 @@
-export { a as DefaultSecretScrubber, D as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, i as isSecretField, m as migratePlaintextSecrets, r as rewriteConfigEncrypted, b as rotateConfigKeys } from '../secret-vault-CImt2XrR.js';
-export { A as AutoApprovePermissionPolicy, D as DefaultPermissionPolicy, P as PermissionPolicyOptions } from '../permission-policy-C8vJcnX5.js';
-export { D as DANGEROUS_FOR_SUBAGENTS, T as ToolCapabilities, a as ToolCapability, g as getDangerousCapabilities, h as hasCapability, b as hasDangerousCapabilityForSubagents } from '../index-nP09-oP2.js';
+export { A as AutoApprovePermissionPolicy, a as DefaultPermissionPolicy, b as DefaultSecretScrubber, D as DefaultSecretVault, P as PermissionPolicyOptions, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, i as isSecretField, m as migratePlaintextSecrets, r as rewriteConfigEncrypted, c as rotateConfigKeys } from '../secret-vault-D7jeyXUQ.js';
+export { D as DANGEROUS_FOR_SUBAGENTS, T as ToolCapabilities, a as ToolCapability, g as getDangerousCapabilities, h as hasCapability, b as hasDangerousCapabilityForSubagents } from '../index-BEFWNZYs.js';
+import '../tool-LVSLiE1s.js';
+import '../input-reader-E-ffP2ee.js';
+import '../permission-B6YAtNFz.js';
 import '../secret-scrubber-3MHDDAtm.js';
 import '../logger-B63L5bTg.js';
 import '../secret-vault-BAKpgFw_.js';
-import '../tool-BkOgs_KL.js';
-import '../input-reader-E-ffP2ee.js';
-import '../permission-Dx6dIqS2.js';

package/dist/security/index.js

@@ -1164,7 +1164,10 @@ var DANGEROUS_FOR_SUBAGENTS = [
   ToolCapabilities.SHELL_ARBITRARY,
   ToolCapabilities.SHELL_RESTRICTED,
   ToolCapabilities.SHELL_EXEC,
-  ToolCapabilities.PACKAGE_INSTALL
+  ToolCapabilities.PACKAGE_INSTALL,
+  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
+  // radius and every fleet worker should coordinate around its peers.
+  ToolCapabilities.COORDINATION_FLEET_READ
 ];
 function hasDangerousCapabilityForSubagents(toolOrCaps) {
   if (!toolOrCaps) return false;