@townco/secret 0.1.49 → 0.1.51

package/dist/index.d.ts

@@ -1,15 +1,13 @@
-export { EnvFile } from "./env-file";
+export { EnvFile } from "@townco/env";
 export { type OnePassword, OnePassword as OpItem } from "./onepassword";
 export type SecretValidation = {
-	key: string;
-	value: string;
-	valid: boolean;
-	error?: string;
+    key: string;
+    value: string;
+    valid: boolean;
+    error?: string;
 };
 export declare const listSecrets: () => Promise<Promise<SecretValidation[]>>;
-export declare const createSecret: (
-	name: string,
-	value: string,
-) => Promise<Promise<void>>;
+export declare const createSecret: (name: string, value: string) => Promise<Promise<void>>;
+export declare const updateSecret: (name: string, value: string) => Promise<Promise<void>>;
 export declare const deleteSecret: (name: string) => Promise<Promise<void>>;
 export declare const genenv: () => Promise<Promise<void>>;

package/dist/index.js

@@ -1,23 +1,12 @@
 import * as path from "node:path";
-import { EnvFile } from "./env-file";
+import { findRoot } from "@townco/core";
+import { EnvFile } from "@townco/env";
 import { OnePassword } from "./onepassword";
-export { EnvFile } from "./env-file";
+export { EnvFile } from "@townco/env";
 export { OnePassword as OpItem } from "./onepassword";
-const ROOT_MARKER = ".root";
 const SECRET_FILE = ".env.in";
 const OP_VAULT = "app";
 const OP_ITEM = "dev";
-const findRoot = async (start = ".") => {
-    const startResolved = path.resolve(start);
-    const rootPath = path.join(startResolved, ROOT_MARKER);
-    if (await Bun.file(rootPath).exists())
-        return startResolved;
-    const parent = path.dirname(startResolved);
-    if (parent === "/") {
-        throw new Error("No root found");
-    }
-    return await findRoot(parent);
-};
 const withOpSignIn = (fn) => async (...args) => {
     await OnePassword.signin();
     return fn(...args);
@@ -51,6 +40,7 @@ const withEnvFile = (fn) => async (...args) => {
             for (const [key, value] of Object.entries(resultSecrets)) {
                 envFile.set(key, value);
             }
+            // Sort the env file before writing
             await writeEnvFile(filePath, envFile);
         }
     }
@@ -70,17 +60,17 @@ export const listSecrets = withOpSignIn(async () => {
         if (value.startsWith('"') && value.endsWith('"')) {
             unquotedValue = value.slice(1, -1);
         }
+        // Skip entries that aren't 1Password references
+        if (!unquotedValue.startsWith("op://")) {
+            continue;
+        }
         const validation = {
             key,
             value: unquotedValue,
             valid: true,
         };
-        if (!validation.value.startsWith("op://")) {
-            validations.push(validation);
-            continue;
-        }
         // Check if field exists in 1Password item
-        if (opItem.has(key)) {
+        if (!opItem.has(key)) {
             validation.valid = false;
             validation.error = `Field '${key}' not found in 1Password item`;
             validations.push(validation);
@@ -110,6 +100,22 @@ export const createSecret = withOpSignIn(async (name, value) => {
         return secrets;
     })();
 });
+export const updateSecret = withOpSignIn(async (name, value) => {
+    // Validate that the secret exists in the env file
+    const root = await findRoot();
+    const filePath = path.join(root, SECRET_FILE);
+    const envFile = await readEnvFile(filePath);
+    const secrets = envFile.toRecord();
+    if (!(name in secrets))
+        throw new Error(`Secret '${name}' not found in ${SECRET_FILE}`);
+    // Fetch the item and validate it exists in 1Password
+    const opItem = await OnePassword.fetch(OP_VAULT, OP_ITEM);
+    if (!opItem.has(name))
+        throw new Error(`Secret '${name}' not found in 1Password item`);
+    // Update the value in 1Password
+    opItem.set(name, value);
+    await opItem.sync();
+});
 export const deleteSecret = withOpSignIn(async (name) => {
     // Fetch the item, delete the field, and sync
     const opItem = await OnePassword.fetch(OP_VAULT, OP_ITEM);

package/dist/onepassword.d.ts

@@ -2,107 +2,101 @@ import type { FullItem } from "@1password/connect";
 /**
  * Represents a change to be made to a 1Password item
  */
-type OnePasswordChange =
-	| {
-			type: "add";
-			key: string;
-			value: string;
-	  }
-	| {
-			type: "update";
-			key: string;
-			value: string;
-	  }
-	| {
-			type: "delete";
-			key: string;
-	  };
+type OnePasswordChange = {
+    type: "add";
+    key: string;
+    value: string;
+} | {
+    type: "update";
+    key: string;
+    value: string;
+} | {
+    type: "delete";
+    key: string;
+};
 /**
  * A data structure that represents a 1Password item and provides
  * methods to detect changes and generate appropriate `op` CLI commands.
  */
 export declare class OnePassword {
-	private vault;
-	private item;
-	private fields;
-	private originalFields;
-	constructor(vault: string, item: string, fields?: Map<string, string>);
-	/**
-	 * Create an OpItem from a 1Password FullItem JSON response
-	 */
-	static fromFullItem(
-		vault: string,
-		itemName: string,
-		fullItem: FullItem,
-	): OnePassword;
-	/**
-	 * Fetch an OpItem from 1Password using the CLI
-	 */
-	static fetch(vault: string, item: string): Promise<OnePassword>;
-	/**
-	 * Sign in to 1Password CLI
-	 */
-	static signin(): Promise<void>;
-	/**
-	 * Get a field value
-	 */
-	get(key: string): string | undefined;
-	/**
-	 * Set a field value (marks as changed)
-	 */
-	set(key: string, value: string): this;
-	/**
-	 * Delete a field (marks as deleted)
-	 */
-	delete(key: string): this;
-	/**
-	 * Check if a field exists
-	 */
-	has(key: string): boolean;
-	/**
-	 * Get all field keys
-	 */
-	keys(): string[];
-	/**
-	 * Get all fields as a record
-	 */
-	toRecord(): Record<string, string>;
-	/**
-	 * Get all field entries
-	 */
-	entries(): IterableIterator<[string, string]>;
-	/**
-	 * Build an op:// reference for a field
-	 */
-	getReference(key: string): string;
-	/**
-	 * Detect changes between original and current state
-	 */
-	detectChanges(): OnePasswordChange[];
-	/**
-	 * Generate op CLI arguments for a single change
-	 */
-	private buildEditArgs;
-	/**
-	 * Apply all changes to 1Password using the op CLI
-	 * Returns the number of changes applied
-	 */
-	sync(): Promise<number>;
-	/**
-	 * Inject secrets from a template file to an output file
-	 * This resolves op:// references to actual values
-	 */
-	static inject(inputPath: string, outputPath: string): Promise<void>;
-	/**
-	 * Create a clone of this OpItem
-	 */
-	clone(): OnePassword;
-	/**
-	 * Reset to original state (discard changes)
-	 */
-	reset(): this;
-	/**
-	 * Check if there are unsaved changes
-	 */
-	hasChanges(): boolean;
+    private vault;
+    private item;
+    private fields;
+    private originalFields;
+    constructor(vault: string, item: string, fields?: Map<string, string>);
+    /**
+     * Create an OpItem from a 1Password FullItem JSON response
+     */
+    static fromFullItem(vault: string, itemName: string, fullItem: FullItem): OnePassword;
+    /**
+     * Fetch an OpItem from 1Password using the CLI
+     */
+    static fetch(vault: string, item: string): Promise<OnePassword>;
+    /**
+     * Sign in to 1Password CLI
+     */
+    static signin(): Promise<void>;
+    /**
+     * Get a field value
+     */
+    get(key: string): string | undefined;
+    /**
+     * Set a field value (marks as changed)
+     */
+    set(key: string, value: string): this;
+    /**
+     * Delete a field (marks as deleted)
+     */
+    delete(key: string): this;
+    /**
+     * Check if a field exists
+     */
+    has(key: string): boolean;
+    /**
+     * Get all field keys
+     */
+    keys(): string[];
+    /**
+     * Get all fields as a record
+     */
+    toRecord(): Record<string, string>;
+    /**
+     * Get all field entries
+     */
+    entries(): IterableIterator<[string, string]>;
+    /**
+     * Build an op:// reference for a field
+     */
+    getReference(key: string): string;
+    /**
+     * Detect changes between original and current state
+     */
+    detectChanges(): OnePasswordChange[];
+    /**
+     * Generate op CLI arguments for a single change
+     */
+    private buildEditArgs;
+    /**
+     * Apply all changes to 1Password using the op CLI
+     * Returns the number of changes applied
+     */
+    sync(): Promise<number>;
+    /**
+     * Inject secrets from a template file to an output file
+     * This resolves op:// references to actual values
+     */
+    static inject(inputPath: string, outputPath: string): Promise<void>;
+    /**
+     * Create a clone of this OpItem
+     */
+    clone(): OnePassword;
+    /**
+     * Reset to original state (discard changes)
+     */
+    reset(): this;
+    /**
+     * Check if there are unsaved changes
+     */
+    hasChanges(): boolean;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/secret",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,12 @@
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@1password/connect": "^1.4.2"
+    "@1password/connect": "^1.4.2",
+    "@townco/env": "0.1.1"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.46",
+    "@townco/core": "0.0.29",
+    "@townco/tsconfig": "0.1.48",
     "@types/bun": "^1.3.1"
   }
 }

package/dist/env-file.d.ts

@@ -1,107 +0,0 @@
-/**
- * Represents a line in an .env file
- */
-type EnvLine =
-	| {
-			type: "comment";
-			content: string;
-	  }
-	| {
-			type: "blank";
-	  }
-	| {
-			type: "entry";
-			key: string;
-			value: string;
-			raw: string;
-	  };
-/**
- * A data structure that represents a parsed .env file while preserving
- * all original content including comments, blank lines, and order.
- */
-export declare class EnvFile {
-	private lines;
-	constructor(lines?: EnvLine[]);
-	/**
-	 * Parse a .env file string into an EnvFile structure
-	 */
-	static parse(content: string): EnvFile;
-	/**
-	 * Serialize the EnvFile back to a string
-	 */
-	toString(): string;
-	/**
-	 * Get all entries as a key-value record
-	 */
-	toRecord(): Record<string, string>;
-	/**
-	 * Find an entry line by key
-	 */
-	private findEntry;
-	/**
-	 * Find the index of an entry by key
-	 */
-	private findEntryIndex;
-	/**
-	 * Create an entry line from key and value
-	 */
-	private createEntry;
-	/**
-	 * Normalize a value by ensuring it's properly quoted
-	 */
-	private normalizeValue;
-	/**
-	 * Find the insertion index for a new entry (before the final blank line if present)
-	 */
-	private findInsertionIndex;
-	/**
-	 * Get the value for a specific key
-	 */
-	get(key: string): string | undefined;
-	/**
-	 * Set a value for a key. If the key exists, updates it in place.
-	 * If it doesn't exist, appends it above the final newline (if present).
-	 * Values are always double quoted.
-	 */
-	set(key: string, value: string): this;
-	/**
-	 * Delete a key-value entry
-	 */
-	delete(key: string): this;
-	/**
-	 * Check if a key exists
-	 */
-	has(key: string): boolean;
-	/**
-	 * Get all keys
-	 */
-	keys(): string[];
-	/**
-	 * Iterate over all entries
-	 */
-	entries(): IterableIterator<[string, string]>;
-	/**
-	 * Apply a function to all entries and return a new EnvFile
-	 */
-	map(fn: (key: string, value: string) => [string, string]): EnvFile;
-	/**
-	 * Filter entries based on a predicate
-	 */
-	filter(fn: (key: string, value: string) => boolean): EnvFile;
-	/**
-	 * Add a comment line
-	 */
-	addComment(content: string): this;
-	/**
-	 * Add a blank line
-	 */
-	addBlank(): this;
-	/**
-	 * Get the raw lines array for custom operations
-	 */
-	getLines(): readonly EnvLine[];
-	/**
-	 * Create a clone of this EnvFile
-	 */
-	clone(): EnvFile;
-}

package/dist/env-file.js

@@ -1,205 +0,0 @@
-/**
- * A data structure that represents a parsed .env file while preserving
- * all original content including comments, blank lines, and order.
- */
-export class EnvFile {
-    lines;
-    constructor(lines = []) {
-        this.lines = lines;
-    }
-    /**
-     * Parse a .env file string into an EnvFile structure
-     */
-    static parse(content) {
-        const lines = content.split("\n").map((line) => {
-            const trimmed = line.trim();
-            if (trimmed === "") {
-                return { type: "blank" };
-            }
-            if (trimmed.startsWith("#")) {
-                return { type: "comment", content: line };
-            }
-            const equalsIndex = line.indexOf("=");
-            if (equalsIndex === -1) {
-                // Malformed line, treat as comment
-                return { type: "comment", content: line };
-            }
-            const key = line.substring(0, equalsIndex).trim();
-            const value = line.substring(equalsIndex + 1);
-            return { type: "entry", key, value, raw: line };
-        });
-        return new EnvFile(lines);
-    }
-    /**
-     * Serialize the EnvFile back to a string
-     */
-    toString() {
-        return this.lines
-            .map((line) => {
-            switch (line.type) {
-                case "blank":
-                    return "";
-                case "comment":
-                    return line.content;
-                case "entry":
-                    return line.raw;
-                default:
-                    throw new Error(`Unknown line type`);
-            }
-        })
-            .join("\n");
-    }
-    /**
-     * Get all entries as a key-value record
-     */
-    toRecord() {
-        return Object.fromEntries(this.entries());
-    }
-    /**
-     * Find an entry line by key
-     */
-    findEntry(key) {
-        const line = this.lines.find((l) => l.type === "entry" && l.key === key);
-        return line;
-    }
-    /**
-     * Find the index of an entry by key
-     */
-    findEntryIndex(key) {
-        return this.lines.findIndex((l) => l.type === "entry" && l.key === key);
-    }
-    /**
-     * Create an entry line from key and value
-     */
-    createEntry(key, value) {
-        const quotedValue = this.normalizeValue(value);
-        return {
-            type: "entry",
-            key,
-            value: quotedValue,
-            raw: `${key}=${quotedValue}`,
-        };
-    }
-    /**
-     * Normalize a value by ensuring it's properly quoted
-     */
-    normalizeValue(value) {
-        // Strip existing quotes if present, then add quotes
-        const unquoted = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
-        return `"${unquoted}"`;
-    }
-    /**
-     * Find the insertion index for a new entry (before the final blank line if present)
-     */
-    findInsertionIndex() {
-        const lastLine = this.lines[this.lines.length - 1];
-        return lastLine?.type === "blank"
-            ? this.lines.length - 1
-            : this.lines.length;
-    }
-    /**
-     * Get the value for a specific key
-     */
-    get(key) {
-        return this.findEntry(key)?.value;
-    }
-    /**
-     * Set a value for a key. If the key exists, updates it in place.
-     * If it doesn't exist, appends it above the final newline (if present).
-     * Values are always double quoted.
-     */
-    set(key, value) {
-        const index = this.findEntryIndex(key);
-        const entry = this.createEntry(key, value);
-        if (index !== -1) {
-            this.lines[index] = entry;
-        }
-        else {
-            this.lines.splice(this.findInsertionIndex(), 0, entry);
-        }
-        return this;
-    }
-    /**
-     * Delete a key-value entry
-     */
-    delete(key) {
-        this.lines = this.lines.filter((l) => !(l.type === "entry" && l.key === key));
-        return this;
-    }
-    /**
-     * Check if a key exists
-     */
-    has(key) {
-        return this.findEntry(key) !== undefined;
-    }
-    /**
-     * Get all keys
-     */
-    keys() {
-        return this.lines
-            .filter((l) => l.type === "entry")
-            .map((l) => l.key);
-    }
-    /**
-     * Iterate over all entries
-     */
-    *entries() {
-        for (const line of this.lines) {
-            if (line.type === "entry") {
-                yield [line.key, line.value];
-            }
-        }
-    }
-    /**
-     * Apply a function to all entries and return a new EnvFile
-     */
-    map(fn) {
-        const newLines = this.lines.map((line) => {
-            if (line.type === "entry") {
-                const [newKey, newValue] = fn(line.key, line.value);
-                return this.createEntry(newKey, newValue);
-            }
-            return line;
-        });
-        return new EnvFile(newLines);
-    }
-    /**
-     * Filter entries based on a predicate
-     */
-    filter(fn) {
-        const newLines = this.lines.filter((line) => {
-            if (line.type === "entry") {
-                return fn(line.key, line.value);
-            }
-            return true; // Keep comments and blank lines
-        });
-        return new EnvFile(newLines);
-    }
-    /**
-     * Add a comment line
-     */
-    addComment(content) {
-        const comment = content.startsWith("#") ? content : `# ${content}`;
-        this.lines.push({ type: "comment", content: comment });
-        return this;
-    }
-    /**
-     * Add a blank line
-     */
-    addBlank() {
-        this.lines.push({ type: "blank" });
-        return this;
-    }
-    /**
-     * Get the raw lines array for custom operations
-     */
-    getLines() {
-        return this.lines;
-    }
-    /**
-     * Create a clone of this EnvFile
-     */
-    clone() {
-        return new EnvFile([...this.lines]);
-    }
-}