lecoffre 0.2.0 → 0.2.1

package/src/lib/one-password-storage.ts

@@ -1,233 +0,0 @@
-import { execFile as execFileCb } from "node:child_process";
-import { promisify } from "node:util";
-import { ProjectNotFoundError, Storage, StorageNotInitializedError } from "./storage.ts";
-
-interface OpItemSummary {
-  id: string;
-  title: string;
-  category: string;
-}
-
-interface OpField {
-  id: string;
-  label: string;
-  value: string;
-  type: string;
-  section?: { id: string; label: string };
-  purpose?: string;
-}
-
-interface OpItemDetail {
-  id: string;
-  title: string;
-  fields: Array<OpField>;
-}
-
-interface ExecError {
-  stderr?: string;
-}
-
-function hasStderr(error: unknown): error is ExecError {
-  return typeof error === "object" && error !== null && "stderr" in error;
-}
-
-function getStderr(error: unknown): string {
-  return hasStderr(error) ? (error.stderr?.trim() ?? "") : "";
-}
-
-function isItemNotFound(error: unknown): boolean {
-  return /isn't an item/i.test(getStderr(error));
-}
-
-function isVaultNotFound(error: unknown): boolean {
-  return /isn't a vault/i.test(getStderr(error));
-}
-
-const execFile = promisify(execFileCb);
-
-async function execOp(...args: Array<string>): Promise<string> {
-  try {
-    const { stdout } = await execFile("op", args);
-    return stdout;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      throw new Error(
-        "1Password CLI (op) is not installed. See https://developer.1password.com/docs/cli/get-started/",
-      );
-    }
-    throw error;
-  }
-}
-
-const VAULT = "lecoffre";
-
-export class OnePasswordStorage extends Storage {
-  private readonly vault: string;
-
-  constructor(vault: string = VAULT) {
-    super();
-    this.vault = vault;
-  }
-
-  private rethrow(error: unknown): never {
-    if (isVaultNotFound(error)) {
-      throw new StorageNotInitializedError(
-        `Vault "${this.vault}" not found. Run "lecoffre init" to create it.`,
-      );
-    }
-    const stderr = getStderr(error);
-    if (stderr !== "") {
-      throw new Error(stderr);
-    }
-    throw error;
-  }
-
-  async init(): Promise<void> {
-    try {
-      await execOp("vault", "get", this.vault, "--format", "json");
-    } catch (error) {
-      if (isVaultNotFound(error)) {
-        await execOp("vault", "create", this.vault);
-        return;
-      }
-      throw error;
-    }
-  }
-
-  private async getItem(project: string): Promise<OpItemDetail | null> {
-    try {
-      const stdout = await execOp(
-        "item",
-        "get",
-        project,
-        "--vault",
-        this.vault,
-        "--format",
-        "json",
-      );
-      return JSON.parse(stdout) as OpItemDetail;
-    } catch (error) {
-      if (isItemNotFound(error)) return null;
-      return this.rethrow(error);
-    }
-  }
-
-  /**
-   * Return only user-defined fields. 1Password items include system fields
-   * (e.g. "notesPlain") that have a `purpose` property set. User-created
-   * fields never have `purpose`, so we use that to distinguish them.
-   */
-  private getUserFields(fields: Array<OpField>): Array<OpField> {
-    return fields.filter(
-      (field) => field.purpose === undefined && field.section?.label !== undefined,
-    );
-  }
-
-  async getProjects(): Promise<Array<string>> {
-    try {
-      const stdout = await execOp("item", "list", "--vault", this.vault, "--format", "json");
-      const items = JSON.parse(stdout) as Array<OpItemSummary>;
-      return items.map((item) => item.title);
-    } catch (error) {
-      return this.rethrow(error);
-    }
-  }
-
-  async getProject(project: string): Promise<Record<string, Record<string, string>>> {
-    const item = await this.getItem(project);
-    if (item === null) {
-      throw new ProjectNotFoundError(project);
-    }
-
-    const envs: Record<string, Record<string, string>> = {};
-    for (const field of this.getUserFields(item.fields)) {
-      const sectionLabel = field.section?.label;
-      if (sectionLabel !== undefined) {
-        envs[sectionLabel] ??= {};
-        envs[sectionLabel][field.label] = field.value;
-      }
-    }
-    return envs;
-  }
-
-  // Note: field values are passed as process arguments and are briefly visible
-  // in /proc/<pid>/cmdline. The 1Password CLI does not support reading field
-  // values from stdin when spawned as a child process (only shell pipes work).
-  async setVariables(project: string, env: string, vars: Record<string, string>): Promise<void> {
-    const item = await this.getItem(project);
-
-    if (item === null) {
-      const fieldAssignments = Object.entries(vars).map(
-        ([key, value]) => `${env}.${key}[concealed]=${value}`,
-      );
-      await execOp(
-        "item",
-        "create",
-        "--vault",
-        this.vault,
-        "--category",
-        "Secure Note",
-        "--title",
-        project,
-        ...fieldAssignments,
-      );
-      return;
-    }
-
-    const operations: Array<string> = [];
-
-    for (const field of this.getUserFields(item.fields)) {
-      if (field.section?.label === env) {
-        operations.push(`${env}.${field.label}[delete]`);
-      }
-    }
-
-    for (const [key, value] of Object.entries(vars)) {
-      operations.push(`${env}.${key}[concealed]=${value}`);
-    }
-
-    if (operations.length > 0) {
-      await execOp("item", "edit", project, "--vault", this.vault, ...operations);
-    }
-  }
-
-  async deleteEnvironment(project: string, env: string): Promise<void> {
-    const item = await this.getItem(project);
-    if (item === null) {
-      return;
-    }
-
-    const userFields = this.getUserFields(item.fields);
-    const sections = new Set<string>();
-    const fieldsToDelete: Array<string> = [];
-
-    for (const field of userFields) {
-      if (field.section?.label !== undefined) {
-        sections.add(field.section.label);
-      }
-      if (field.section?.label === env) {
-        fieldsToDelete.push(`${env}.${field.label}[delete]`);
-      }
-    }
-
-    if (fieldsToDelete.length === 0) {
-      return;
-    }
-
-    if (sections.size <= 1 && sections.has(env)) {
-      await execOp("item", "delete", project, "--vault", this.vault);
-      return;
-    }
-
-    await execOp("item", "edit", project, "--vault", this.vault, ...fieldsToDelete);
-  }
-
-  async deleteProject(project: string): Promise<void> {
-    try {
-      await execOp("item", "delete", project, "--vault", this.vault);
-    } catch (error) {
-      if (isItemNotFound(error)) return;
-      this.rethrow(error);
-    }
-  }
-}

package/src/lib/parse-command.ts

@@ -1,108 +0,0 @@
-import { parse } from "@bomb.sh/args";
-import { ZodError } from "zod";
-import type { AnyCommandDefinition } from "./define-command.ts";
-import type { OptionDefinition } from "./define-option.ts";
-import { isBoolean } from "./zod-utils.ts";
-
-export class CommandValidationError extends Error {
-  errors: Array<string>;
-
-  constructor(errors: Array<string>) {
-    super(errors.join("\n"));
-    this.errors = errors;
-  }
-}
-
-export class CommandHelpRequested extends Error {
-  constructor() {
-    super("Help requested");
-  }
-}
-
-export function parseCommand(
-  argv: Array<string>,
-  command: AnyCommandDefinition,
-): { options: Record<string, unknown>; args: Array<unknown> } {
-  const commandOptions = command.options ?? {};
-  const commandArgs = command.args ?? [];
-
-  const parseOpts = buildParseOptions(commandOptions);
-  const raw = parse(argv, parseOpts);
-
-  if (raw["help"]) {
-    throw new CommandHelpRequested();
-  }
-
-  const errors: Array<string> = [];
-
-  const options: Record<string, unknown> = {};
-  for (const [key, opt] of Object.entries(commandOptions)) {
-    const rawValue = raw[opt.name] as unknown;
-    try {
-      if (rawValue !== undefined) {
-        options[key] = opt.schema.parse(rawValue);
-      } else {
-        options[key] = opt.schema.parse(undefined);
-      }
-    } catch (error) {
-      if (error instanceof ZodError) {
-        for (const issue of error.issues) {
-          errors.push(`option "--${opt.name}": ${issue.message}`);
-        }
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  const args: Array<unknown> = [];
-  for (let i = 0; i < commandArgs.length; i++) {
-    const argDef = commandArgs[i]!;
-    const rawValue = raw._[i];
-    try {
-      if (rawValue !== undefined) {
-        args.push(argDef.schema.parse(String(rawValue)));
-      } else {
-        args.push(argDef.schema.parse(undefined));
-      }
-    } catch (error) {
-      if (error instanceof ZodError) {
-        for (const issue of error.issues) {
-          errors.push(`argument <${argDef.placeholder}>: ${issue.message}`);
-        }
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    throw new CommandValidationError(errors);
-  }
-
-  return { options, args };
-}
-
-function buildParseOptions(options: Record<string, OptionDefinition>) {
-  const boolean: Array<string> = [];
-  const string: Array<string> = [];
-  const alias: Record<string, string> = {};
-
-  for (const opt of Object.values(options)) {
-    if (isBoolean(opt.schema)) {
-      boolean.push(opt.name);
-    } else {
-      string.push(opt.name);
-    }
-    if (opt.aliases !== undefined) {
-      for (const a of opt.aliases) {
-        alias[a] = opt.name;
-      }
-    }
-  }
-
-  boolean.push("help");
-  alias["h"] = "help";
-
-  return { boolean, string, alias };
-}

package/src/lib/shell.ts

@@ -1,52 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { basename } from "node:path";
-
-const SUPPORTED_SHELLS = ["bash", "zsh", "fish"] as const;
-
-export type ShellName = (typeof SUPPORTED_SHELLS)[number];
-
-function isSupportedShell(name: string): name is ShellName {
-  return (SUPPORTED_SHELLS as ReadonlyArray<string>).includes(name);
-}
-
-export function detectShell(): ShellName {
-  const name = basename(
-    execFileSync("ps", ["-p", String(process.ppid), "-o", "comm="], { encoding: "utf-8" }).trim(),
-  );
-  if (isSupportedShell(name)) {
-    return name;
-  }
-  throw new Error(`Unsupported shell: ${name}`);
-}
-
-export function formatVariables(shell: ShellName, vars: Record<string, string>): string {
-  const lines = Object.entries(vars).map(([key, value]) => formatSingleVariable(shell, key, value));
-  return lines.join("\n");
-}
-
-function formatSingleVariable(shell: ShellName, key: string, value: string): string {
-  if (shell === "fish") {
-    return `set -gx ${key} '${escapeSingleQuotes(value, "fish")}'`;
-  }
-  return `export ${key}='${escapeSingleQuotes(value, "posix")}'`;
-}
-
-export function formatUnsetVariables(shell: ShellName, keys: Array<string>): string {
-  const lines = keys.map((key) => formatSingleUnsetVariable(shell, key));
-  return lines.join("\n");
-}
-
-function formatSingleUnsetVariable(shell: ShellName, key: string): string {
-  if (shell === "fish") {
-    return `set -e ${key}`;
-  }
-  return `unset ${key}`;
-}
-
-function escapeSingleQuotes(value: string, mode: "posix" | "fish"): string {
-  if (mode === "fish") {
-    return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
-  }
-  // In POSIX shells: end quote, escaped quote, restart quote
-  return value.replaceAll("'", "'\\''");
-}

package/src/lib/storage.ts

@@ -1,37 +0,0 @@
-export class ProjectNotFoundError extends Error {
-  readonly project: string;
-
-  constructor(project: string) {
-    super(`Project not found: ${project}`);
-    this.name = "ProjectNotFoundError";
-    this.project = project;
-  }
-}
-
-export class EnvironmentNotFoundError extends Error {
-  readonly project: string;
-  readonly environment: string;
-
-  constructor(project: string, environment: string) {
-    super(`Environment not found: ${environment}`);
-    this.name = "EnvironmentNotFoundError";
-    this.project = project;
-    this.environment = environment;
-  }
-}
-
-export class StorageNotInitializedError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "StorageNotInitializedError";
-  }
-}
-
-export abstract class Storage {
-  abstract init(): Promise<void>;
-  abstract getProjects(): Promise<Array<string>>;
-  abstract getProject(project: string): Promise<Record<string, Record<string, string>>>;
-  abstract setVariables(project: string, env: string, vars: Record<string, string>): Promise<void>;
-  abstract deleteEnvironment(project: string, env: string): Promise<void>;
-  abstract deleteProject(project: string): Promise<void>;
-}

package/src/lib/zod-utils.ts

@@ -1,50 +0,0 @@
-import type { z } from "zod";
-
-interface ZodDef {
-  type?: string;
-  innerType?: z.ZodType;
-  defaultValue?: unknown;
-  in?: z.ZodType;
-}
-
-function getDef(schema: z.ZodType): ZodDef {
-  return (schema as unknown as { _zod: { def: ZodDef } })._zod.def;
-}
-
-export function isBoolean(schema: z.ZodType): boolean {
-  const def = getDef(schema);
-  if (def.type === "boolean") return true;
-  if (def.type === "default" || def.type === "optional" || def.type === "nullable") {
-    if (def.innerType !== undefined) return isBoolean(def.innerType);
-  }
-  return false;
-}
-
-export function isRequired(schema: z.ZodType): boolean {
-  const def = getDef(schema);
-  if (def.type === "default" || def.type === "optional" || def.type === "nullable") {
-    return false;
-  }
-  if (def.type === "pipe" && def.in !== undefined) {
-    return isRequired(def.in);
-  }
-  return true;
-}
-
-export function getDefault(schema: z.ZodType): unknown {
-  let current: z.ZodType | undefined = schema;
-  while (current !== undefined) {
-    const def = getDef(current);
-    if (def.type === "default") return def.defaultValue;
-    if (def.type === "optional" || def.type === "nullable") {
-      current = def.innerType;
-      continue;
-    }
-    if (def.type === "pipe") {
-      current = def.in;
-      continue;
-    }
-    break;
-  }
-  return undefined;
-}

package/src/options/environment.option.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-import { defineOption } from "../lib/define-option.ts";
-
-export const environmentOption = defineOption({
-  name: "environment",
-  schema: z.string().default("default"),
-  description: "Environment name",
-  aliases: ["e"],
-  placeholder: "env",
-});

package/src/options/project.option.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-import { defineOption } from "../lib/define-option.ts";
-
-export const projectOption = defineOption({
-  name: "project",
-  schema: z
-    .string()
-    .refine((val) => !val.startsWith("-"), { message: 'must not start with "-"' })
-    .optional(),
-  description: "Project name",
-  aliases: ["p"],
-  placeholder: "name",
-});