@kitlangton/ghui 0.1.19 → 0.1.21

package/src/services/BrowserOpener.ts

@@ -0,0 +1,22 @@
+import { Context, Effect, Layer } from "effect"
+import type { PullRequestItem } from "../domain.js"
+import { CommandRunner, type CommandError } from "./CommandRunner.js"
+
+export class BrowserOpener extends Context.Service<BrowserOpener, {
+	readonly openPullRequest: (pullRequest: PullRequestItem) => Effect.Effect<void, CommandError>
+}>()("ghui/BrowserOpener") {
+	static readonly layerNoDeps = Layer.effect(
+		BrowserOpener,
+		Effect.gen(function*() {
+			const command = yield* CommandRunner
+
+			const openPullRequest = Effect.fn("BrowserOpener.openPullRequest")(function*(pullRequest: PullRequestItem) {
+				yield* command.run("gh", ["pr", "view", String(pullRequest.number), "--repo", pullRequest.repository, "--web"])
+			})
+
+			return BrowserOpener.of({ openPullRequest })
+		}),
+	)
+
+	static readonly layer = BrowserOpener.layerNoDeps.pipe(Layer.provide(CommandRunner.layer))
+}

package/src/services/Clipboard.ts

@@ -0,0 +1,46 @@
+import { Context, Effect, Layer, Schema } from "effect"
+import { CommandRunner } from "./CommandRunner.js"
+
+export class ClipboardError extends Schema.TaggedErrorClass<ClipboardError>()("ClipboardError", {
+	detail: Schema.String,
+}) {}
+
+const clipboardCommands: readonly (readonly [string, ...readonly string[]])[] =
+	process.platform === "darwin" ? [["pbcopy"]]
+	: process.platform === "linux" ? [
+		...(process.env.WAYLAND_DISPLAY ? [["wl-copy"] as const] : []),
+		["xclip", "-selection", "clipboard"] as const,
+		["xsel", "--clipboard", "--input"] as const,
+	]
+	: []
+
+const installHint = process.platform === "linux" ? " Install wl-clipboard, xclip, or xsel." : ""
+const unavailableDetail = `Clipboard is not available.${installHint}`
+
+export class Clipboard extends Context.Service<Clipboard, {
+	readonly copy: (text: string) => Effect.Effect<void, ClipboardError>
+}>()("ghui/Clipboard") {
+	static readonly layerNoDeps = Layer.effect(
+		Clipboard,
+		Effect.gen(function*() {
+			const command = yield* CommandRunner
+
+			const copy = Effect.fn("Clipboard.copy")(function*(text: string) {
+				if (clipboardCommands.length === 0) {
+					return yield* new ClipboardError({ detail: unavailableDetail })
+				}
+				let lastDetail = ""
+				for (const [cmd, ...args] of clipboardCommands) {
+					const result = yield* command.run(cmd, args, { stdin: text }).pipe(Effect.result)
+					if (result._tag === "Success") return
+					lastDetail = result.failure.detail
+				}
+				return yield* new ClipboardError({ detail: lastDetail || unavailableDetail })
+			})
+
+			return Clipboard.of({ copy })
+		}),
+	)
+
+	static readonly layer = Clipboard.layerNoDeps.pipe(Layer.provide(CommandRunner.layer))
+}

package/src/services/CommandRunner.ts

@@ -6,6 +6,10 @@ export interface CommandResult {
 	readonly exitCode: number
 }
 
+export interface RunOptions {
+	readonly stdin?: string
+}
+
 export class CommandError extends Schema.TaggedErrorClass<CommandError>()("CommandError", {
 	command: Schema.String,
 	args: Schema.Array(Schema.String),
@@ -26,22 +30,26 @@ const readStream = async (stream: ReadableStream | null | undefined) => {
 }
 
 export class CommandRunner extends Context.Service<CommandRunner, {
-	readonly run: (command: string, args: readonly string[]) => Effect.Effect<CommandResult, CommandError>
-	readonly runJson: <A>(command: string, args: readonly string[]) => Effect.Effect<A, CommandError | JsonParseError>
+	readonly run: (command: string, args: readonly string[], options?: RunOptions) => Effect.Effect<CommandResult, CommandError>
 	readonly runSchema: <S extends Schema.Top>(schema: S, command: string, args: readonly string[]) =>
 		Effect.Effect<S["Type"], CommandError | JsonParseError | Schema.SchemaError, S["DecodingServices"]>
 }>()("ghui/CommandRunner") {
 	static readonly layer = Layer.effect(
 		CommandRunner,
 		Effect.gen(function*() {
-			const runProcess = Effect.fn("CommandRunner.runProcess")((command: string, args: readonly string[]) =>
+			const runProcess = Effect.fn("CommandRunner.runProcess")((command: string, args: readonly string[], stdin: string | undefined) =>
 				Effect.tryPromise({
 					async try() {
 						const proc = Bun.spawn({
 							cmd: [command, ...args],
+							stdin: stdin === undefined ? "ignore" : "pipe",
 							stdout: "pipe",
 							stderr: "pipe",
 						})
+						if (stdin !== undefined && proc.stdin) {
+							proc.stdin.write(stdin)
+							proc.stdin.end()
+						}
 
 						const [exitCode, stdout, stderr] = await Promise.all([proc.exited, readStream(proc.stdout), readStream(proc.stderr)])
 						return { stdout, stderr, exitCode }
@@ -50,8 +58,8 @@ export class CommandRunner extends Context.Service<CommandRunner, {
 				})
 			)
 
-			const run = Effect.fn("CommandRunner.run")(function*(command: string, args: readonly string[]) {
-				const result = yield* runProcess(command, args).pipe(Effect.withSpan("ghui.command.runProcess", {
+			const run = Effect.fn("CommandRunner.run")(function*(command: string, args: readonly string[], options?: RunOptions) {
+				const result = yield* runProcess(command, args, options?.stdin).pipe(Effect.withSpan("ghui.command.runProcess", {
 					attributes: {
 						"process.command": command,
 						"process.argv.count": args.length,
@@ -77,7 +85,7 @@ export class CommandRunner extends Context.Service<CommandRunner, {
 				return yield* Schema.decodeUnknownEffect(schema)(value)
 			})
 
-			return CommandRunner.of({ run, runJson, runSchema })
+			return CommandRunner.of({ run, runSchema })
 		}),
 	)
 }