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

package/src/entrypoints/ozy-signing-agent.ts

@@ -1,48 +0,0 @@
-import { appendFileSync } from "node:fs";
-import { Effect, Layer, pipe } from "effect";
-import { OSPlatformImpl } from "@/modules/common/os-platform/impl";
-import { CryptoImpl } from "@/modules/common/crypto/impl";
-import { KeyMapStoreImpl } from "@/modules/common/kep-map-store/impl";
-import { SSHConfigImpl } from "@/modules/common/ssh-config/impl";
-import { SSHAgentImpl } from "@/modules/ssh-agent/ssh-agent/impl";
-import { SessionImpl } from "@/modules/ssh-agent/session/impl";
-import { AGENT_LOG_FILE_PATH, AGENT_PID_FILE_PATH, AGENT_PORT_FILE_PATH, AGENT_SOCK_FILE_PATH } from "@/common/constants";
-import { rmSync } from "node:fs";
-
-const origLog = console.log.bind(console);
-const origError = console.error.bind(console);
-const origWarn = console.warn.bind(console);
-
-function logToFile(...args: any[]) {
-  try { 
-    appendFileSync(AGENT_LOG_FILE_PATH, args.map(arg => {
-      try { return JSON.stringify(arg) }
-      catch(e) { return String(e); }
-    }).join(' ') + '\n'); 
-  } catch {}
-}
-
-console.log = (...args: any[]) => { logToFile(...args); origLog(...args); };
-console.error = (...args: any[]) => { logToFile(...args); origError(...args); };
-console.warn = (...args: any[]) => { logToFile(...args); origWarn(...args); };
-
-function cleanup() {
-  try { rmSync(AGENT_PID_FILE_PATH); } catch {}
-  try { rmSync(AGENT_PORT_FILE_PATH); } catch {}
-  try { rmSync(AGENT_SOCK_FILE_PATH); } catch {}
-}
-
-process.on("exit", cleanup);
-process.on("SIGTERM", () => { cleanup(); process.exit(0); });
-process.on("SIGINT", () => { cleanup(); process.exit(0); });
-
-pipe(
-  SSHAgentImpl.ServiceLayer,
-  Layer.provideMerge(SessionImpl.makeRpcLayer()),
-  Layer.provideMerge(KeyMapStoreImpl.Layer),
-  Layer.provideMerge(SSHConfigImpl.Layer),
-  Layer.provideMerge(CryptoImpl.Layer),
-  Layer.provideMerge(OSPlatformImpl.Layer),
-  Layer.launch,
-  Effect.runPromise
-);

package/src/entrypoints/ozy-ssh-keygen.ts

@@ -1,10 +0,0 @@
-import { AGENT_SOCK_FILE_PATH } from "@/common/constants";
-
-const result = Bun.spawnSync(["ssh-keygen", ...Bun.argv.slice(2)], {
-  stdin: "inherit",
-  stdout: "inherit",
-  stderr: "inherit",
-  env: { ...process.env, SSH_AUTH_SOCK: AGENT_SOCK_FILE_PATH },
-});
-
-process.exit(result.exitCode ?? 1);

package/src/entrypoints/ozy-virtual-security-key.ts

@@ -1,21 +0,0 @@
-import { Effect } from "effect";
-import { appendFileSync } from "node:fs";
-import { commonModules } from "@/modules/common";
-import { OSPlatformImpl } from "@/modules/common/os-platform/impl";
-import { VIRTUAL_KEY_LOG_FILE_PATH } from "@/common/constants";
-
-const program = Effect.gen(function* () {
-  const platform = yield* commonModules.OSPlatform;
-  yield* platform.registerVirtualHID((data) =>
-    Effect.sync(() => {
-      appendFileSync(VIRTUAL_KEY_LOG_FILE_PATH, `[vhid] received ${data.length} bytes: ${data.toString('hex')}\n`);
-      return Buffer.alloc(64);
-    })
-  );
-  yield* Effect.never;
-}).pipe(Effect.provide(OSPlatformImpl.Layer));
-
-Effect.runPromise(program).catch(e => {
-  console.error('Virtual security key failed:', e);
-  process.exit(1);
-});

package/src/entrypoints/ozy.ts

@@ -1,2 +0,0 @@
-// TODO: we should move commands to its own layer
-import '@/commands';

package/src/index.ts

@@ -1 +0,0 @@
-export {};

package/src/internal/thing.ts

@@ -1,3 +0,0 @@
-export function time() {
-  console.log("is with us all");
-}

package/src/modules/cli/agent-client/impl.ts

@@ -1,152 +0,0 @@
-import { Effect, Layer, Match, Option, pipe, Data, FileSystem, Schedule, Result } from "effect";
-import { effunct, implementing, type EffectGen } from "effective-modules";
-import { FetchHttpClient } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import { AgentRpcGroup } from "@/modules/ssh-agent/session/interface-rpc";
-import { cliModules } from "..";
-import { type AgentRpcClient, type IAgentClient, AgentClientError } from "./interface";
-import { AGENT_CMD_PATH, AGENT_PID_FILE_PATH, AGENT_PORT_FILE_PATH, AGENT_SOCK_FILE_PATH, CURRENT_VERSION } from "@/common/constants";
-import { readFileSync, rmSync } from "node:fs";
-import { log } from "@/common/log";
-
-function makeAgentClientLayer(port: number) {
-  return pipe(
-    RpcClient.layerProtocolHttp({ url: `http://localhost:${port}/rpc` }),
-    Layer.provideMerge(RpcSerialization.layerJson),
-    Layer.provideMerge(FetchHttpClient.layer)
-  );
-}
-
-class NoResponseError extends Data.TaggedError("NoResponseError")<{}> {
-  public toString() { return "No response from agent."; }
-}
-
-class NonMatchingVersionError extends Data.TaggedError("NonMatchingVersionError")<{
-  cliVersion: string;
-  agentVersion: string;
-}> {
-  public toString() {
-    return `Agent running but with mismatched version ${this.agentVersion} compared to CLI version ${this.cliVersion}`;
-  }
-}
-
-type PingError = NoResponseError | NonMatchingVersionError;
-
-export class AgentClientImpl extends implementing(cliModules.AgentClient).uses(FileSystem.FileSystem) implements IAgentClient {
-  private *readPortFromFile(): EffectGen<Option.Option<number>, never> {
-    const result = yield* pipe(
-      this.getDependency(FileSystem.FileSystem).readFileString(AGENT_PORT_FILE_PATH),
-      Effect.result
-    );
-    if (Result.isFailure(result)) return Option.none();
-    const port = parseInt(result.success.trim());
-    if (isNaN(port) || port <= 0 || port > 65535) {
-      log(`Read out of bounds port ${port}`);
-      return Option.none();
-    }
-    return Option.some(port);
-  }
-
-  private *pingAtPort(port: number): EffectGen<void, PingError> {
-    yield* Effect.scoped(
-      Effect.gen(function* () {
-        const client = yield* RpcClient.make(AgentRpcGroup);
-        const { version } = yield* pipe(
-          client.GetVersion({}),
-          Effect.catchTag("RpcClientError", () => new NoResponseError())
-        );
-        if (version !== CURRENT_VERSION)
-          yield* new NonMatchingVersionError({ cliVersion: CURRENT_VERSION, agentVersion: version });
-      })
-    ).pipe(Effect.provide(makeAgentClientLayer(port)));
-  }
-
-  private *ping(): EffectGen<{ port: number }, PingError> {
-    const portOption = yield* effunct(this.readPortFromFile)();
-    if (Option.isNone(portOption)) return yield* new NoResponseError();
-    const port = portOption.value;
-    yield* effunct(this.pingAtPort)(port);
-    return { port };
-  }
-
-  private *waitForPidFile(expectedPid: number): EffectGen<void, string> {
-    const fs = this.getDependency(FileSystem.FileSystem);
-    yield* pipe(
-      Effect.retry(
-        pipe(
-          fs.readFileString(AGENT_PID_FILE_PATH),
-          Effect.catchTag("PlatformError", () => Effect.fail("pid file not yet written")),
-          Effect.flatMap(content => {
-            const pid = parseInt(content.trim());
-            return pid === expectedPid
-              ? Effect.void
-              : Effect.fail(`PID mismatch: expected ${expectedPid}, got ${pid}`);
-          })
-        ),
-        Schedule.spaced("50 millis")
-      ),
-      Effect.timeout("5 seconds"),
-      Effect.mapError(() => "Agent did not start within 5 seconds")
-    );
-  }
-
-  private *startAgent(): EffectGen<{ pid: number; port: number }, string | PingError> {
-    const proc = Bun.spawn([AGENT_CMD_PATH], { stdout: "ignore", stderr: "ignore" });
-    yield* effunct(this.waitForPidFile)(proc.pid);
-    const { port } = yield* effunct(this.ping)();
-    log(`Started agent at PID ${proc.pid}`);
-    return { pid: proc.pid, port };
-  }
-
-  *killIfRunning(): EffectGen<void, string> {
-    try {
-      // Throws if file missing
-      const pidFileContent = readFileSync(AGENT_PID_FILE_PATH, "utf-8");
-      const PID = parseInt(pidFileContent.trim());
-      // If doesn't exist, below line throws
-      process.kill(PID, 0);
-      log(`Killing agent on PID ${PID}`);
-      process.kill(PID, "SIGTERM");
-      yield* Effect.sleep(500);
-    } catch { }
-    try { rmSync(AGENT_PID_FILE_PATH); } catch {}
-    try { rmSync(AGENT_PORT_FILE_PATH); } catch {}
-    try { rmSync(AGENT_SOCK_FILE_PATH); } catch {}
-  }
-
-  private *ensureRunning(): EffectGen<{ port: number }, string> {
-    const pingResult = yield* pipe(effunct(this.ping)(), Effect.result);
-    if (Result.isSuccess(pingResult)) return pingResult.success;
-    log(pingResult.failure.toString());
-    yield* Match.value(pingResult.failure).pipe(
-      Match.tag("NonMatchingVersionError", () => effunct(this.killIfRunning)()),
-      Match.tag("NoResponseError", () => effunct(this.killIfRunning)()),
-      Match.exhaustive
-    );
-    return yield* pipe(
-      effunct(this.startAgent)(),
-      Effect.mapError(err =>
-        typeof err === "string" ?
-          err :
-          `Failed to start agent due to ${err.name}: ${err.toString()}`
-      )
-    );
-  }
-
-  *usingClient<A, E>(use: (client: AgentRpcClient) => EffectGen<A, E>): EffectGen<A, AgentClientError<E>> {
-    const { port } = yield* pipe(
-      effunct(this.ensureRunning)(),
-      Effect.mapError(reason => new AgentClientError.ClientError({ reason }))
-    );
-    return yield* pipe(
-      Effect.scoped(
-        Effect.gen(function* () {
-          const client = yield* RpcClient.make(AgentRpcGroup);
-          return yield* use(client);
-        })
-      ),
-      Effect.provide(makeAgentClientLayer(port)),
-      Effect.mapError(e => new AgentClientError.UsageError({ cause: e }))
-    );
-  }
-}

package/src/modules/cli/agent-client/interface.ts

@@ -1,17 +0,0 @@
-import type { EffectGen } from "effective-modules";
-import type { AgentRpcGroup } from "@/modules/ssh-agent/session/interface-rpc";
-import type { RpcClient, RpcClientError as RpcClientErrorModule, RpcGroup } from "effect/unstable/rpc";
-import { Data } from "effect";
-
-export type AgentRpcClient = RpcClient.RpcClient<RpcGroup.Rpcs<AgentRpcGroup>, RpcClientErrorModule.RpcClientError>;
-
-export namespace AgentClientError {
-  export class UsageError<E> extends Data.TaggedError("AgentClientUsageError")<{ readonly cause: E }> {}
-  export class ClientError extends Data.TaggedError("AgentClientError")<{ readonly reason: string }> {}
-}
-export type AgentClientError<E> = AgentClientError.UsageError<E> | AgentClientError.ClientError;
-
-export interface IAgentClient {
-  killIfRunning(): EffectGen<void, string>;
-  usingClient<A, E>(use: (client: AgentRpcClient) => EffectGen<A, E>): EffectGen<A, AgentClientError<E>>;
-}

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

@@ -1,133 +0,0 @@
-import { implementing, type EffectGen } from "effective-modules";
-import { cliModules } from "..";
-import { commonModules } from "@/modules/common";
-import { $ } from 'bun';
-import type { IGit, SetupRepoInput } from "./interface";
-import { Effect, Option, pipe } from "effect";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { SSH_KEYGEN_CMD_PATH, STANDARD_REMOTE_PREFIX } from "@/common/constants";
-import { Gitmodules } from "./submodule/gitmodules";
-import { readGitState } from "./submodule/git-state";
-import { fixGitConfig, fixModuleDirs, fixIndexGitlinks } from "./submodule/fix";
-import { printSyncState, printFixes } from "./submodule/printer";
-
-export class GitImpl extends implementing(cliModules.Git).uses(commonModules.OSPlatform, commonModules.SSHConfig) implements IGit {
-  private parseOwnerRepo(remote: string): Effect.Effect<{ owner: string; repo: string }, string> {
-    const sshMatch = remote.match(/^git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/);
-    if (sshMatch) return Effect.succeed({ owner: sshMatch[1]!, repo: sshMatch[2]! });
-    const httpsMatch = remote.match(/^https?:\/\/[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/);
-    if (httpsMatch) return Effect.succeed({ owner: httpsMatch[1]!, repo: httpsMatch[2]! });
-    return Effect.fail(`Cannot parse owner/repo from remote: ${remote}`);
-  }
-  
-  *resolveOwnerAndRepo(maybeOwnerAndRepo: Option.Option<string>): EffectGen<{ owner: string; repo: string; }, string> {
-    if (Option.isSome(maybeOwnerAndRepo)) {
-      const parts = maybeOwnerAndRepo.value.split('/');
-      const [owner, repo] = parts;
-      if (parts.length !== 2 || !owner || !repo)
-        return yield* Effect.fail(`Cannot parse remote error: Expected "owner/repo", got "${maybeOwnerAndRepo.value}"`);
-      return { owner, repo };
-    }
-
-    if (!(yield* this.isGitRepository())) {
-      yield* Effect.fail(`not in git repo: Current directory is not a git repository`);
-    }
-
-    const remoteOption = yield* this.getRemoteOrigin();
-    if (Option.isNone(remoteOption)) {
-      return yield* Effect.fail(`no remote origin: No remote.origin.url — pass owner/repo as argument to clone instead`);
-    }
-
-    return yield* this.parseOwnerRepo(remoteOption.value);
-  }
-  *isGitRepository(): EffectGen<boolean> {
-    return yield* pipe(
-      Effect.tryPromise(async () => {
-        await $`git rev-parse --is-inside-work-tree`.quiet();
-        return true;
-      }),
-      Effect.catchTag("UnknownError", () => Effect.succeed(false))
-    );
-  }
-  *getRemoteOrigin(): EffectGen<Option.Option<string>> {
-    return yield* pipe(
-      Effect.tryPromise(async() => {
-        return Option.some((await $`git config --get remote.origin.url`.quiet()).text().trim());
-      }),
-      Effect.catchTag("UnknownError", () => Effect.succeed(Option.none()))
-    )
-  }
-  *clone(owner: string, repo: string): EffectGen<void, string> {
-    const result = Bun.spawnSync(['git', 'clone', '--recurse-submodules', `${STANDARD_REMOTE_PREFIX}${owner}/${repo}.git`], { stdout: 'inherit', stderr: 'inherit' });
-    if (result.exitCode !== 0)
-      return yield* Effect.fail(`git clone failed with exit code ${result.exitCode}`);
-    process.chdir(`./${repo}`);
-  }
-  *setLocalConfig(key: string, value: string): EffectGen<void, string> {
-    yield* Effect.tryPromise({
-      try: async () => { await $`git config --local ${key} ${value}`.quiet(); },
-      catch: (e) => `git config ${key}: ${e instanceof Error ? e.message : String(e)}`,
-    });
-  }
-  private *configureRepo({ dir, remoteURL, user, pubkeyPath }: SetupRepoInput): EffectGen<void, string> {
-    yield* Effect.log(`Configuring ${dir}`);
-    yield* Effect.tryPromise({
-      try: async () => {
-        const configs: [string, string][] = [
-          ['remote.origin.url', remoteURL],
-          ['user.name', user.name],
-          ['user.email', user.email],
-          ['user.signingkey', pubkeyPath],
-          ['gpg.format', 'ssh'],
-          ['gpg.ssh.program', SSH_KEYGEN_CMD_PATH],
-          ['commit.gpgsign', 'true'],
-          ['tag.gpgsign', 'true'],
-        ];
-        for (const [k, v] of configs) {
-          const r = Bun.spawnSync(['git', 'config', '--local', k, v], { cwd: dir, stdout: 'pipe', stderr: 'pipe' });
-          if (r.exitCode !== 0) {
-            const err = new TextDecoder().decode(r.stderr);
-            throw new Error(`git config ${k} failed: ${err.trim()}`);
-          }
-        }
-      },
-      catch: (e) => e instanceof Error ? e.message : String(e),
-    });
-  }
-  private *syncSubmoduleState(repoRoot: string, topLevelRoot: string): EffectGen<Gitmodules, string> {
-    const gitmodules = yield* Gitmodules.fromRepoRoot(repoRoot);
-    if (gitmodules.list.length === 0) return gitmodules;
-    const submodulePaths = gitmodules.list.map(m => m.path);
-    const state = yield* readGitState(repoRoot, submodulePaths);
-    printSyncState(gitmodules, state);
-    const fixResults = yield* Effect.all(
-      [
-        fixGitConfig(repoRoot, gitmodules),
-        fixModuleDirs(repoRoot, gitmodules, state.moduleDirs, state.orphanModuleDirs, topLevelRoot),
-        fixIndexGitlinks(repoRoot, gitmodules, state.index),
-      ],
-      { concurrency: "unbounded" },
-    );
-    printFixes(fixResults.flat());
-    return gitmodules;
-  }
-  *setupRepo(input: SetupRepoInput): EffectGen<void, string> {
-    yield* this.setupRepoAt(input, input.dir);
-  }
-  private *setupRepoAt(input: SetupRepoInput, topLevelRoot: string): EffectGen<void, string> {
-    yield* this.configureRepo(input);
-    if (!existsSync(resolve(input.dir, '.gitmodules'))) return;
-    const gitmodules = yield* this.syncSubmoduleState(input.dir, topLevelRoot);
-    for (const m of gitmodules.list) {
-      const subDir = resolve(input.dir, m.path);
-      if (!existsSync(subDir)) continue;
-      yield* this.setupRepoAt({
-        dir: subDir,
-        remoteURL: m.url,
-        user: input.user,
-        pubkeyPath: input.pubkeyPath
-      }, topLevelRoot);
-    }
-  }
-}

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

@@ -1,23 +0,0 @@
-import { type EffectGen} from "effective-modules";
-import { Option } from "effect";
-
-export interface GitUser {
-  name: string;
-  email: string;
-}
-
-export interface SetupRepoInput {
-  dir: string;
-  user: GitUser;
-  pubkeyPath: string;
-  remoteURL: string;
-}
-
-export interface IGit {
-  isGitRepository(): EffectGen<boolean>;
-  getRemoteOrigin(): EffectGen<Option.Option<string>>;
-  resolveOwnerAndRepo(maybeOwnerAndRepo: Option.Option<string>): EffectGen<{owner: string; repo: string;}, string>;
-  clone(owner: string, repo: string): EffectGen<void, string>;
-  setLocalConfig(key: string, value: string): EffectGen<void, string>;
-  setupRepo(params: SetupRepoInput): EffectGen<void, string>;
-}