@ozyman42/ozy-cli 0.4.8 → 0.4.9-darwin-arm64.0

package/src/modules/cli/git/submodule/printer.ts

@@ -1,256 +0,0 @@
-import type { Gitmodules } from "./gitmodules";
-import type { GitState, ModuleDirInfo, IndexGitlink, WorkingTreeGitEntry } from "./git-state";
-import type { Fix } from "./fix";
-
-const RED = "\x1b[31m";
-const GREEN = "\x1b[32m";
-const CYAN = "\x1b[36m";
-const DIM = "\x1b[2m";
-const BOLD = "\x1b[1m";
-const RESET = "\x1b[0m";
-
-const ok = `${GREEN}✓${RESET}`;
-const fail = (msg: string) => `${RED}✗ ${msg}${RESET}`;
-const fsName = (s: string) => `${CYAN}${s}${RESET}`;
-const key = (s: string) => `${DIM}${s}${RESET}`;
-
-interface Line {
-  label: string;
-  isKey?: boolean;  // dim key style instead of cyan fs style
-  value?: string;
-  status?: string;
-  children?: Line[];
-}
-
-function render(lines: Line[], prefix = ""): void {
-  for (let i = 0; i < lines.length; i++) {
-    const last = i === lines.length - 1;
-    const branch = last ? "└── " : "├── ";
-    const child = last ? "    " : "│   ";
-    const l = lines[i];
-    const label = l.isKey ? key(l.label) : fsName(l.label);
-    let out = `${prefix}${branch}${label}`;
-    if (l.value !== undefined) out += `: ${l.value}`;
-    if (l.status !== undefined) out += `  ${l.status}`;
-    console.log(out);
-    if (l.children?.length) render(l.children, prefix + child);
-  }
-}
-
-function buildPathTree(parts: string[], children: Line[]): Line {
-  if (parts.length === 1) return { label: parts[0], children };
-  return { label: parts[0], children: [buildPathTree(parts.slice(1), children)] };
-}
-
-function resultLine(label: string, result: string | { error: string } | undefined): Line {
-  if (result === undefined) return { label, isKey: true, status: fail("unknown") };
-  if (typeof result === "string") return { label, isKey: true, value: result };
-  return { label, isKey: true, status: fail(result.error) };
-}
-
-function moduleHasIssues(
-  m: { path: string; url: string },
-  cfg: { path?: string; url?: string } | undefined,
-  dir: ModuleDirInfo | undefined,
-  idx: IndexGitlink | undefined,
-  headSha: string | undefined,
-  wt: WorkingTreeGitEntry | undefined,
-): boolean {
-  if (!cfg) return true;
-  if (cfg.path !== m.path || cfg.url !== m.url) return true;
-  if (!dir) return true;
-  if (!idx) return true;
-  if (headSha && idx.commit !== headSha) return true;
-  if (!wt || wt.type === "missing" || wt.type === "dir") return true;
-  if (typeof wt.headCommit !== "string") return true;
-  if (typeof wt.remote !== "string" || wt.remote !== m.url) return true;
-  return false;
-}
-
-export function printSyncState(modules: Gitmodules, state: GitState): void {
-  const byName = new Map(state.config.map((c) => [c.name, c]));
-  const byPath = new Map(state.moduleDirs.map((d) => [d.relativePath, d]));
-  const byIndexPath = new Map(state.index.map((i) => [i.path, i]));
-  const byTreePath = new Map(state.workingTree.map((w) => [w.path, w]));
-  const modulePaths = new Set(modules.list.map((m) => m.path));
-  const moduleNames = new Set(modules.list.map((m) => m.name));
-
-  console.log("=== syncing submodules ===");
-
-  for (const m of modules.list) {
-    const cfg = byName.get(m.name);
-    const dir = byPath.get(m.path);
-    const idx = byIndexPath.get(m.path);
-    const wt = byTreePath.get(m.path);
-    const headSha = typeof wt?.headCommit === "string" ? wt.headCommit : undefined;
-
-    if (!moduleHasIssues(m, cfg, dir, idx, headSha, wt)) {
-      console.log(`${BOLD}[${m.name}]${RESET} ${ok}`);
-      continue;
-    }
-
-    console.log(`${BOLD}[${m.name}]${RESET}`);
-
-    // .gitmodules
-    const gitmodulesNode: Line = {
-      label: ".gitmodules",
-      children: [
-        { label: "path", isKey: true, value: m.path },
-        { label: "url", isKey: true, value: m.url },
-      ],
-    };
-
-    // .git/config
-    let configNode: Line;
-    if (!cfg) {
-      configNode = { label: "config", status: fail("missing") };
-    } else {
-      configNode = {
-        label: "config",
-        children: [
-          {
-            label: "path",
-            isKey: true,
-            value: cfg.path ?? "(missing)",
-            status: cfg.path === m.path ? ok : fail(`expected ${m.path}`),
-          },
-          {
-            label: "url",
-            isKey: true,
-            value: cfg.url ?? "(missing)",
-            status: cfg.url === m.url ? ok : fail(`expected ${m.url}`),
-          },
-        ],
-      };
-    }
-
-    // .git/modules
-    const modulesNode: Line = {
-      label: "modules",
-      children: [{ label: m.path, status: dir ? ok : fail("missing") }],
-    };
-
-    // .git/index
-    let indexNode: Line;
-    if (!idx) {
-      indexNode = { label: "index", status: fail("missing") };
-    } else {
-      const idxSha8 = idx.commit.slice(0, 8);
-      const matches = headSha && idx.commit === headSha;
-      const mismatches = headSha && idx.commit !== headSha;
-      indexNode = {
-        label: "index",
-        value: idxSha8,
-        status: matches ? ok : mismatches ? fail(`head is ${headSha.slice(0, 8)}`) : undefined,
-      };
-    }
-
-    const dotGitNode: Line = {
-      label: ".git",
-      children: [configNode, modulesNode, indexNode],
-    };
-
-    // working tree leaves
-    const wtLeaves: Line[] = [];
-
-    if (!wt || wt.type === "missing") {
-      wtLeaves.push({ label: ".git", status: fail("missing") });
-    } else if (wt.type === "dir") {
-      wtLeaves.push({ label: ".git", status: fail("directory (standalone clone)") });
-    } else {
-      wtLeaves.push({ label: ".git", value: `gitdir → ${wt.gitdirTarget}` });
-    }
-
-    if (wt) {
-      const head = headSha ?? wt.headCommit;
-      wtLeaves.push(resultLine("head", typeof head === "string" ? head.slice(0, 8) : head));
-
-      if (typeof wt.remote === "string") {
-        wtLeaves.push({
-          label: "remote",
-          isKey: true,
-          value: wt.remote,
-          status: wt.remote === m.url ? ok : fail(`expected ${m.url}`),
-        });
-      } else {
-        wtLeaves.push(resultLine("remote", wt.remote));
-      }
-    }
-
-    const workingTreeNode = buildPathTree(m.path.split("/"), wtLeaves);
-
-    render([gitmodulesNode, dotGitNode, workingTreeNode]);
-  }
-
-  // Stale entries
-  const staleConfig = state.config.filter((c) => !moduleNames.has(c.name));
-  const staleDirs = state.moduleDirs.filter((d) => !modulePaths.has(d.relativePath));
-  const staleIndex = state.index.filter((i) => !modulePaths.has(i.path));
-
-  if (staleConfig.length || staleDirs.length || state.orphanModuleDirs.length || staleIndex.length) {
-    console.log(`\n${RED}${BOLD}=== stale (not in .gitmodules) ===${RESET}`);
-    const staleNodes: Line[] = [];
-
-    if (staleConfig.length) {
-      staleNodes.push({
-        label: ".git/config",
-        children: staleConfig.map((c) => ({ label: c.name })),
-      });
-    }
-    if (staleDirs.length || state.orphanModuleDirs.length) {
-      staleNodes.push({
-        label: ".git/modules",
-        children: [
-          ...staleDirs.map((d) => ({ label: d.relativePath })),
-          ...state.orphanModuleDirs.map((d) => ({ label: d })),
-        ],
-      });
-    }
-    if (staleIndex.length) {
-      staleNodes.push({
-        label: ".git/index",
-        children: staleIndex.map((i) => ({ label: i.path, isKey: true, value: i.commit.slice(0, 8) })),
-      });
-    }
-
-    render(staleNodes);
-  }
-}
-
-type FixTree = Map<string, { subtree: FixTree; fixes: Fix[] }>;
-
-function addToFixTree(tree: FixTree, fix: Fix, depth = 0): void {
-  const seg = fix.location[depth];
-  if (!tree.has(seg)) tree.set(seg, { subtree: new Map(), fixes: [] });
-  const node = tree.get(seg)!;
-  if (depth === fix.location.length - 1) {
-    node.fixes.push(fix);
-  } else {
-    addToFixTree(node.subtree, fix, depth + 1);
-  }
-}
-
-function fixTreeToLines(tree: FixTree): Line[] {
-  const lines: Line[] = [];
-  for (const [label, { subtree, fixes }] of tree) {
-    const children = fixTreeToLines(subtree);
-    if (fixes.length > 0) {
-      for (const fix of fixes) {
-        const actionStr = fix.action === "deleted" ? `${RED}deleted${RESET}` : `${GREEN}synced${RESET}`;
-        const status = fix.detail ? `${actionStr}  ${fix.detail}` : actionStr;
-        lines.push({ label, status, children: children.length > 0 ? children : undefined });
-      }
-    } else {
-      lines.push({ label, children });
-    }
-  }
-  return lines;
-}
-
-export function printFixes(fixes: Fix[]): void {
-  if (fixes.length === 0) return;
-  const tree: FixTree = new Map();
-  for (const fix of fixes) addToFixTree(tree, fix);
-  console.log("\napplied fixes:");
-  render(fixTreeToLines(tree));
-}

package/src/modules/cli/git/submodule/resolve-git-dir.ts

@@ -1,14 +0,0 @@
-import { statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-
-// A submodule's .git is a redirect file ("gitdir: <relative path>"), not a directory —
-// resolve it to the real git dir so callers don't try to treat the file as a directory.
-export async function resolveGitDir(repoRoot: string): Promise<string> {
-  const dotGit = resolve(repoRoot, ".git");
-  if (statSync(dotGit).isDirectory()) return dotGit;
-  const content = await readFile(dotGit, "utf8");
-  const match = content.match(/^gitdir:\s*(.+)$/m);
-  if (!match) throw new Error(`Malformed .git file at ${dotGit}`);
-  return resolve(repoRoot, match[1]!.trim());
-}

package/src/modules/cli/github/impl.ts

@@ -1,169 +0,0 @@
-import { Deferred, Effect, Schema } from "effect";
-import { implementing, type EffectGen } from "effective-modules";
-import { cliModules } from "@/modules/cli";
-import { commonModules } from "@/modules/common";
-import { log } from "@/common/log";
-import type { IGitHub, GitHubUser, GitHubSshSigningKey, GitHubAuthnKey } from "./interface";
-
-const API_BASE = 'https://api.github.com';
-const API_VERSION = '2022-11-28';
-
-const OAUTH_SUCCESS_HTML = `<!DOCTYPE html>
-<html><head><title>Authorization successful</title></head>
-<body><h1>Authorization successful</h1>
-<p>You can close this tab and return to the terminal.</p>
-</body></html>`;
-
-const GitHubUserSchema = Schema.Struct({
-  login: Schema.String,
-  name: Schema.String,
-  id: Schema.Int
-});
-
-const GitHubEmailSchema = Schema.Struct({
-  email: Schema.String,
-  primary: Schema.Boolean,
-  verified: Schema.Boolean,
-});
-
-const GitHubSshSigningKeySchema = Schema.Struct({
-  id: Schema.Int,
-  title: Schema.String,
-  key: Schema.String,
-});
-
-const GitHubAuthnKeySchema = Schema.Struct({
-  id: Schema.Int,
-  title: Schema.String,
-  key: Schema.String,
-});
-
-export class GitHubImpl extends implementing(cliModules.GitHub).uses(commonModules.OSPlatform) implements IGitHub {
-  private api<A>(token: string, method: string, path: string, schema: Schema.Schema<A>, body?: unknown, debug?: boolean): Effect.Effect<{ status: number; data: A }, string> {
-    return Effect.tryPromise({
-      try: async () => {
-        const res = await fetch(`${API_BASE}${path}`, {
-          method,
-          headers: {
-            'Authorization': `Bearer ${token}`,
-            'Accept': 'application/vnd.github+json',
-            'X-GitHub-Api-Version': API_VERSION,
-            ...(body ? { 'Content-Type': 'application/json' } : {}),
-          },
-          ...(body ? { body: JSON.stringify(body) } : {}),
-        });
-        const rawData = await res.json();
-        if (debug) log(`[debug] ${method} ${path} (${res.status}):\n${JSON.stringify(rawData, null, 2)}`);
-        return { status: res.status, rawData };
-      },
-      catch: (e) => `GitHub API request failed: ${e instanceof Error ? e.message : String(e)}`,
-    }).pipe(
-      Effect.flatMap(({ status, rawData }) =>
-        (Schema.decodeUnknownEffect(schema)(rawData) as Effect.Effect<A, unknown, never>).pipe(
-          Effect.map(data => ({ status, data })),
-          Effect.mapError(parseError =>
-            status < 200 || status >= 300
-              ? `${method} ${path} returned HTTP ${status}`
-              : `Failed to parse ${method} ${path} response: ${String(parseError)}`
-          )
-        )
-      )
-    );
-  }
-
-  *authorize(clientId: string, clientSecret: string, scopes: string): EffectGen<string, string> {
-    const osPlatform = this.dependencies.OSPlatform;
-    return yield* Effect.scoped(Effect.gen(function* () {
-      const state = crypto.randomUUID();
-      const deferred = yield* Deferred.make<string, string>();
-
-      const server = yield* Effect.acquireRelease(
-        Effect.sync(() => Bun.serve({
-          port: 0,
-          async fetch(req) {
-            const url = new URL(req.url);
-            if (url.pathname === '/callback') {
-              const code = url.searchParams.get('code');
-              const returnedState = url.searchParams.get('state');
-              if (returnedState !== state) {
-                Effect.runFork(Deferred.fail(deferred, 'State mismatch — possible CSRF attack'));
-                return new Response('State mismatch', { status: 400 });
-              }
-              if (!code) {
-                Effect.runFork(Deferred.fail(deferred, 'Missing authorization code in callback'));
-                return new Response('Missing code', { status: 400 });
-              }
-              Effect.runFork(Deferred.succeed(deferred, code));
-              return new Response(OAUTH_SUCCESS_HTML, { headers: { 'Content-Type': 'text/html' } });
-            }
-            return new Response('Not found', { status: 404 });
-          },
-        })),
-        (server) => Effect.sync(() => server.stop()),
-      );
-
-      const redirectUri = `http://localhost:${server.port}/callback`;
-      const authUrl = new URL('https://github.com/login/oauth/authorize');
-      authUrl.searchParams.set('client_id', clientId);
-      authUrl.searchParams.set('scope', scopes);
-      authUrl.searchParams.set('state', state);
-      authUrl.searchParams.set('redirect_uri', redirectUri);
-      authUrl.searchParams.set('prompt', 'select_account');
-
-      log('Opening browser for GitHub authorization...');
-      yield* osPlatform.openBrowserWindow(authUrl.toString());
-
-      const code = yield* Deferred.await(deferred);
-
-      const tokenRes = yield* Effect.tryPromise({
-        try: () => fetch('https://github.com/login/oauth/access_token', {
-          method: 'POST',
-          headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-          body: JSON.stringify({ client_id: clientId, client_secret: clientSecret, code, redirect_uri: redirectUri }),
-        }),
-        catch: () => 'Token exchange request failed',
-      });
-
-      const tokenData = yield* Effect.tryPromise({
-        try: () => tokenRes.json() as Promise<{ access_token?: string; error?: string; error_description?: string }>,
-        catch: () => 'Failed to parse token exchange response',
-      });
-
-      if (!tokenData.access_token)
-        return yield* Effect.fail(tokenData.error_description ?? tokenData.error ?? 'Token exchange failed');
-
-      return tokenData.access_token;
-    }));
-  }
-
-  *getUser(token: string): EffectGen<GitHubUser, string> {
-    const { data: { login, name, id } } = yield* this.api(token, 'GET', '/user', GitHubUserSchema);
-    const { data: emails } = yield* this.api(token, 'GET', '/user/emails', Schema.Array(GitHubEmailSchema));
-    const primaryEmail = emails.find(e => e.primary);
-    if (!primaryEmail)
-      return yield* Effect.fail(`No primary email found on GitHub account — add one at github.com/settings/emails`);
-    return { login, name, email: primaryEmail.email, id };
-  }
-
-  *getSigningKeys(token: string): EffectGen<GitHubSshSigningKey[], string> {
-    const { data } = yield* this.api(token, 'GET', '/user/ssh_signing_keys', Schema.Array(GitHubSshSigningKeySchema));
-    return data as GitHubSshSigningKey[];
-  }
-
-  *addSigningKey(token: string, title: string, key: string): EffectGen<void, string> {
-    const { status } = yield* this.api(token, 'POST', '/user/ssh_signing_keys', Schema.Unknown, { title, key });
-    if (status !== 201)
-      yield* Effect.fail(`POST /user/ssh_signing_keys returned HTTP ${status}`);
-  }
-
-  *getAuthnKeys(token: string): EffectGen<readonly GitHubAuthnKey[], string> {
-    const { data } = yield* this.api(token, 'GET', `/user/keys`, Schema.Array(GitHubAuthnKeySchema));
-    return data;
-  }
-
-  *addAuthnKey(token: string, title: string, key: string): EffectGen<void, string> {
-    const { status } = yield* this.api(token, 'POST', `/user/keys`, Schema.Unknown, { title, key });
-    if (status !== 201)
-      yield* Effect.fail(`POST /user/keys returned HTTP ${status}`);
-  }
-}

package/src/modules/cli/github/interface.ts

@@ -1,29 +0,0 @@
-import type { EffectGen } from "effective-modules";
-
-export interface GitHubUser {
-  login: string;
-  name: string;
-  email: string;
-  id: number;
-}
-
-export interface GitHubSshSigningKey {
-  id: number;
-  title: string;
-  key: string;
-}
-
-export interface GitHubAuthnKey {
-  readonly id: number;
-  readonly title: string;
-  readonly key: string;
-}
-
-export interface IGitHub {
-  authorize(clientId: string, clientSecret: string, scopes: string): EffectGen<string, string>;
-  getUser(token: string): EffectGen<GitHubUser, string>;
-  getSigningKeys(token: string): EffectGen<GitHubSshSigningKey[], string>;
-  addSigningKey(token: string, title: string, key: string): EffectGen<void, string>;
-  getAuthnKeys(token: string): EffectGen<readonly GitHubAuthnKey[], string>;
-  addAuthnKey(token: string, title: string, key: string): EffectGen<void, string>;
-}

package/src/modules/cli/index.ts

@@ -1,16 +0,0 @@
-import { interfaces } from "effective-modules";
-import type { IGit } from "./git/interface";
-import type { IGitHub } from "./github/interface";
-import type { IAgentClient } from "./agent-client/interface";
-
-export enum CLIModules {
-  Git = "Git",
-  GitHub = "GitHub",
-  AgentClient = "AgentClient",
-}
-
-export const cliModules = interfaces<CLIModules, {
-  Git: IGit;
-  GitHub: IGitHub;
-  AgentClient: IAgentClient;
-}>(CLIModules);

package/src/modules/common/crypto/impl.ts

@@ -1,173 +0,0 @@
-import { Effect, pipe } from "effect";
-import { implementing, type EffectGen } from "effective-modules";
-import { commonModules } from "@/modules/common";
-import type { DecryptInput, ECDHKeyPair, ICrypto } from "./interface";
-import bs58 from "bs58";
-import friendlyWords from "friendly-words";
-import { sign as cryptoSign, createPrivateKey, createPublicKey } from "node:crypto";
-import { FUTURE_TOOL_NAME } from "@/common/constants";
-
-function toBase64url(bytes: Uint8Array): string {
-  return Buffer.from(bytes).toString("base64url");
-}
-
-function fromBase64url(str: string): Uint8Array {
-  return new Uint8Array(Buffer.from(str, "base64url"));
-}
-
-function u32(n: number): Buffer {
-  const b = Buffer.allocUnsafe(4);
-  b.writeUInt32BE(n, 0);
-  return b;
-}
-
-function sshString(s: Buffer): Buffer {
-  return Buffer.concat([u32(s.length), s]);
-}
-
-// PKCS#8 DER header for Ed25519
-const PKCS8_ED25519_HEADER = Buffer.from("302e020100300506032b657004220420", "hex");
-
-export class CredentialId {
-  public readonly base64: string;
-  public readonly raw: Uint8Array;
-  public readonly humanReadableName: string;
-  public static fromBase64(base64: string) {
-    const base58 = bs58.encode(fromBase64url(base64));
-    return new this(base58);
-  }
-  public constructor(public readonly base58: string) {
-    this.raw = bs58.decode(base58);
-    this.base64 = toBase64url(this.raw);
-    // Extract three non-overlapping bit windows: 11 + 11 + 12 = 34 bits from bytes 0-4
-    const b = this.raw;
-    const adj1Idx = ((b[0]! << 3) | (b[1]! >> 5)) % friendlyWords.predicates.length;
-    const adj2Idx = (((b[1]! & 0x1F) << 6) | (b[2]! >> 2)) % friendlyWords.predicates.length;
-    const nounIdx = (((b[2]! & 0x3) << 10) | (b[3]! << 2) | (b[4]! >> 6)) % friendlyWords.objects.length;
-    this.humanReadableName = [
-      FUTURE_TOOL_NAME,
-      friendlyWords.predicates[adj1Idx],
-      friendlyWords.predicates[adj2Idx],
-      friendlyWords.objects[nounIdx]
-    ].join("-");
-  }
-}
-
-export class SSHPubkey {
-  readonly wire: Buffer;
-  readonly keyType: string;
-  readonly authorizedKey: string;
-
-  private constructor(wire: Buffer) {
-    this.wire = wire;
-    const len = wire.readUInt32BE(0);
-    this.keyType = wire.subarray(4, 4 + len).toString("utf8");
-    this.authorizedKey = `${this.keyType} ${wire.toString("base64")}`;
-  }
-
-  static fromWire(wire: Buffer): SSHPubkey {
-    return new SSHPubkey(wire);
-  }
-
-  static fromAuthorizedKey(s: string): SSHPubkey {
-    return new SSHPubkey(Buffer.from(s.split(" ")[1]!, "base64"));
-  }
-}
-
-export class SSHKeyPair {
-  readonly pubkey: SSHPubkey;
-  private readonly pemPrivateKey: string;
-
-  private constructor(pubkey: SSHPubkey, pemPrivateKey: string) {
-    this.pubkey = pubkey;
-    this.pemPrivateKey = pemPrivateKey;
-  }
-
-  sign(data: Buffer): Buffer {
-    return cryptoSign(null, data, createPrivateKey(this.pemPrivateKey));
-  }
-
-  static fromSeed(seed: Uint8Array, context: string): Effect.Effect<SSHKeyPair, string> {
-    return Effect.tryPromise({
-      try: async () => {
-        const hkdfKey = await crypto.subtle.importKey("raw", seed, "HKDF", false, ["deriveBits"]);
-        const bits = await crypto.subtle.deriveBits(
-          { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: new TextEncoder().encode(context) } as any,
-          hkdfKey,
-          256
-        );
-        return SSHKeyPair.build(new Uint8Array(bits));
-      },
-      catch: (e) => String(e),
-    });
-  }
-
-  private static build(seed: Uint8Array): SSHKeyPair {
-    const der = Buffer.concat([PKCS8_ED25519_HEADER, Buffer.from(seed)]);
-    const priv = createPrivateKey({ key: der, format: "der", type: "pkcs8" });
-    const spki = createPublicKey(priv).export({ type: "spki", format: "der" }) as Buffer;
-    const pubBytes = Buffer.from(spki.subarray(-32));
-
-    const keyTypeBuf = Buffer.from("ssh-ed25519");
-    const wire = Buffer.concat([sshString(keyTypeBuf), sshString(pubBytes)]);
-
-    const pemPrivateKey = priv.export({ type: "pkcs8", format: "pem" }) as string;
-
-    return new SSHKeyPair(SSHPubkey.fromWire(wire), pemPrivateKey);
-  }
-}
-
-const { Crypto } = commonModules;
-
-export class CryptoImpl extends implementing(Crypto) implements ICrypto {
-  
-  *getRandomChallenge(): EffectGen<string> {
-    return toBase64url(crypto.getRandomValues(new Uint8Array(16)));
-  }
-  
-  *createECDHKey(): EffectGen<ECDHKeyPair, string> {
-    const keyPair = yield* Effect.tryPromise({
-      try: () => crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]),
-      catch: (e) => (e as Error).toString(),
-    });
-    const agentPubKeyRaw = yield* Effect.tryPromise({
-      try: () => crypto.subtle.exportKey("raw", keyPair.publicKey),
-      catch: (e) => (e as Error).toString(),
-    });
-    const pubkey = toBase64url(new Uint8Array(agentPubKeyRaw));
-    return {
-      base64Pubkey: pubkey,
-      keyPair,
-    }
-  }
-
-  *decrypt({cipherText, iv, hkdfInfo, receiverKey, senderPubkey}: DecryptInput): EffectGen<Uint8Array, string> {
-    return yield* pipe(
-      Effect.tryPromise(async () => {
-        const browserPubKey = await crypto.subtle.importKey(
-          "raw", fromBase64url(senderPubkey),
-          { name: "ECDH", namedCurve: "P-256" }, false, []
-        );
-        const sharedBits = await crypto.subtle.deriveBits(
-          { name: "ECDH", public: browserPubKey }, receiverKey.privateKey, 256
-        );
-        const hkdfKey = await crypto.subtle.importKey("raw", sharedBits, "HKDF", false, ["deriveKey"]);
-        const aesKey = await crypto.subtle.deriveKey(
-          {
-            name: "HKDF", hash: "SHA-256",
-            salt: new Uint8Array(32),
-            info: new TextEncoder().encode(hkdfInfo),
-          },
-          hkdfKey, { name: "AES-GCM", length: 256 }, false, ["decrypt"]
-        );
-        const decrypted = await crypto.subtle.decrypt(
-          { name: "AES-GCM", iv: fromBase64url(iv) },
-          aesKey, fromBase64url(cipherText)
-        );
-        return new Uint8Array(decrypted);
-      }),
-      Effect.catchTag("UnknownError", err => Effect.fail(err.message))
-    );
-  }
-
-}

package/src/modules/common/crypto/interface.ts

@@ -1,20 +0,0 @@
-import { type EffectGen } from "effective-modules";
-
-export interface ECDHKeyPair {
-  base64Pubkey: string;
-  keyPair: CryptoKeyPair;
-}
-
-export interface DecryptInput {
-  cipherText: string;
-  iv: string;
-  senderPubkey: string;
-  receiverKey: CryptoKeyPair;
-  hkdfInfo: string;
-}
-
-export interface ICrypto {
-  getRandomChallenge(): EffectGen<string>;
-  createECDHKey(): EffectGen<ECDHKeyPair, string>;
-  decrypt(input: DecryptInput): EffectGen<Uint8Array, string>;
-}