@ozyman42/ozy-cli 0.4.8-linux-x64.0 → 0.4.8

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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,21 @@
+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

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

package/src/index.ts

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

package/src/internal/thing.ts

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

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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,23 @@
+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>;
+}