@kitlangton/tailcode 0.2.2 → 0.2.4

package/src/flow.ts

@@ -1,115 +0,0 @@
-import { Deferred, Effect, Layer } from "effect"
-import { appRuntime } from "./runtime.js"
-import { registry, phase, step, log, url, error, missingBinary } from "./state.js"
-import { Tailscale } from "./services/tailscale.js"
-import { OpenCode } from "./services/opencode.js"
-import { AppConfig } from "./services/config.js"
-import { stripTerminalControl, trim } from "./qr.js"
-import { BinaryNotFound } from "./services/errors.js"
-
-function append(line: string) {
-  const clean = stripTerminalControl(line)
-  if (!clean) return
-  registry.update(log, (prev) => trim(prev + clean, 16_000))
-}
-
-// Resolved when the user requests a clean exit so the scope finalizer runs
-const exitSignal = Deferred.makeUnsafe<void>()
-let exitSignaled = false
-let flowRunning = false
-const shutdownWaiters = new Set<() => void>()
-
-function resolveShutdownWaiters() {
-  for (const resolve of shutdownWaiters) resolve()
-  shutdownWaiters.clear()
-}
-
-export function signalExit() {
-  if (exitSignaled) return
-  exitSignaled = true
-  Deferred.doneUnsafe(exitSignal, Effect.succeed(undefined))
-}
-
-export function waitForFlowStop() {
-  if (!flowRunning) return Promise.resolve()
-  return new Promise<void>((resolve) => {
-    shutdownWaiters.add(resolve)
-  })
-}
-
-export const flowFn = appRuntime.fn<void>()(() =>
-  Effect.gen(function* () {
-    flowRunning = true
-    registry.set(missingBinary, "")
-
-    const config = yield* AppConfig
-    const tailscale = yield* Tailscale
-    const opencode = yield* OpenCode
-
-    // Step 1: Tailscale — ensure connected
-    registry.set(step, "tailscale")
-    const bin = yield* tailscale.ensure(append)
-
-    // Step 2: OpenCode — start server (handle lives in scope via ChildProcess.spawn)
-    registry.set(step, "opencode")
-    yield* opencode.start(config.port, config.password, append)
-
-    // Step 3: Publish via tailscale serve
-    registry.set(step, "publish")
-    const remote = yield* tailscale.publish(bin, config.port, append)
-
-    registry.set(url, remote)
-    registry.set(log, "")
-    registry.set(step, "idle")
-    registry.set(missingBinary, "")
-    registry.set(phase, "done")
-
-    // Hold scope open (keeping finalizer alive) until quit is signalled.
-    // Re-triggering flowFn interrupts this fiber instead.
-    yield* Deferred.await(exitSignal)
-  }).pipe(
-    Effect.catch((err) =>
-      Effect.sync(() => {
-        if ((err as any)?._tag === "BinaryNotFound") {
-          const missing = err as BinaryNotFound
-          registry.set(error, `${missing.binary} is not installed`)
-          if (missing.binary === "tailscale" || missing.binary === "opencode") {
-            registry.set(missingBinary, missing.binary)
-          } else {
-            registry.set(missingBinary, "")
-          }
-          registry.set(phase, "install")
-          return
-        }
-
-        registry.set(missingBinary, "")
-        registry.set(error, "message" in err ? (err as any).message : String(err))
-        registry.set(phase, "error")
-      }),
-    ),
-    Effect.provide(Layer.mergeAll(Tailscale.layer, OpenCode.layer)),
-    Effect.ensuring(
-      Effect.sync(() => {
-        flowRunning = false
-        resolveShutdownWaiters()
-      }),
-    ),
-  ),
-)
-
-function gracefulProcessExit() {
-  signalExit()
-  const fallback = setTimeout(() => process.exit(0), 5000)
-  void waitForFlowStop().finally(() => {
-    clearTimeout(fallback)
-    process.exit(0)
-  })
-}
-
-// Signal handlers
-process.on("SIGINT", () => {
-  gracefulProcessExit()
-})
-process.on("SIGTERM", () => {
-  gracefulProcessExit()
-})

package/src/main.tsx

@@ -1,23 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-
-// Explicitly load the OpenTUI Solid preload (normally done via bunfig.toml in dev)
-import "@opentui/solid/preload"
-
-import { render } from "@opentui/solid"
-import { RegistryContext } from "@effect/atom-solid/RegistryContext"
-import { App } from "./app.js"
-import { registry } from "./state.js"
-
-// -- Render --
-
-render(
-  () => (
-    <RegistryContext.Provider value={registry}>
-      <App />
-    </RegistryContext.Provider>
-  ),
-  {
-    targetFps: 60,
-    exitOnCtrlC: false,
-  },
-)

package/src/qr.ts

@@ -1,118 +0,0 @@
-import QRCode from "qrcode"
-
-const ANSI_ESCAPE_RE = new RegExp(
-  `[${String.fromCharCode(27)}${String.fromCharCode(155)}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`,
-  "g",
-)
-
-export function trim(value: string, max: number) {
-  if (value.length <= max) return value
-  return value.slice(value.length - max)
-}
-
-export function parseURL(value: string) {
-  const stripped = stripTerminalControl(value)
-  return stripped.match(/https?:\/\/[^\s)]+/)?.[0]
-}
-
-export function stripTerminalControl(value: string) {
-  return value.replace(ANSI_ESCAPE_RE, "").replace(/\r/g, "")
-}
-
-export function qrCell(data: ReadonlyArray<number | boolean> | Uint8Array, size: number, x: number, y: number) {
-  if (x < 0 || y < 0 || x >= size || y >= size) return false
-  return Boolean((data as any)[y * size + x])
-}
-
-export function renderQR(value: string) {
-  const result = QRCode.create(value, { errorCorrectionLevel: "L" })
-  const size = result.modules.size
-  const data = result.modules.data as unknown as ReadonlyArray<number | boolean> | Uint8Array
-
-  const border = 2
-  const lines: string[] = []
-
-  for (let y = -border; y < size + border; y += 2) {
-    let line = ""
-    for (let x = -border; x < size + border; x++) {
-      const top = qrCell(data, size, x, y)
-      const bot = qrCell(data, size, x, y + 1)
-      if (top && bot) line += "█"
-      else if (top) line += "▀"
-      else if (bot) line += "▄"
-      else line += " "
-    }
-    lines.push(line)
-  }
-
-  return lines.join("\n")
-}
-
-export async function copyToClipboard(text: string) {
-  const runWithStdin = async (cmd: string, args: string[] = []) => {
-    try {
-      const proc = Bun.spawn([cmd, ...args], {
-        stdin: "pipe",
-        stdout: "ignore",
-        stderr: "ignore",
-      })
-      proc.stdin.write(text)
-      proc.stdin.end()
-      return (await proc.exited) === 0
-    } catch {
-      return false
-    }
-  }
-
-  if (process.platform === "darwin") {
-    if (!(await runWithStdin("pbcopy"))) throw new Error("Failed to copy to clipboard")
-    return
-  }
-
-  if (process.platform === "win32") {
-    if (!(await runWithStdin("clip"))) throw new Error("Failed to copy to clipboard")
-    return
-  }
-
-  const linuxTools: ReadonlyArray<{ cmd: string; args: string[] }> = [
-    { cmd: "wl-copy", args: [] },
-    { cmd: "xclip", args: ["-selection", "clipboard"] },
-    { cmd: "xsel", args: ["--clipboard", "--input"] },
-  ]
-
-  for (const tool of linuxTools) {
-    if (!Bun.which(tool.cmd)) continue
-    if (await runWithStdin(tool.cmd, tool.args)) return
-  }
-
-  throw new Error("No supported clipboard tool found")
-}
-
-export async function openInBrowser(url: string) {
-  const run = async (cmd: string, args: string[]) => {
-    try {
-      const proc = Bun.spawn([cmd, ...args], {
-        stdin: "ignore",
-        stdout: "ignore",
-        stderr: "ignore",
-      })
-      return (await proc.exited) === 0
-    } catch {
-      return false
-    }
-  }
-
-  if (process.platform === "darwin") {
-    if (!(await run("open", [url]))) throw new Error("Failed to open browser")
-    return
-  }
-
-  if (process.platform === "win32") {
-    if (!(await run("cmd", ["/c", "start", "", url]))) {
-      throw new Error("Failed to open browser")
-    }
-    return
-  }
-
-  if (!(await run("xdg-open", [url]))) throw new Error("Failed to open browser")
-}

package/src/runtime.ts

@@ -1,6 +0,0 @@
-import * as Atom from "effect/unstable/reactivity/Atom"
-import { Layer } from "effect"
-import { AppConfig } from "./services/config.js"
-import { BunServices } from "@effect/platform-bun"
-
-export const appRuntime = Atom.runtime(Layer.mergeAll(AppConfig.layer, BunServices.layer))

package/src/services/config.ts

@@ -1,28 +0,0 @@
-import { Config, Effect, Layer, Redacted, Schema, ServiceMap } from "effect"
-
-const Port = Schema.Int.pipe(Schema.brand("Port"))
-type Port = typeof Port.Type
-
-const Password = Schema.Redacted(Schema.String).pipe(Schema.brand("Password"))
-type Password = typeof Password.Type
-
-export class AppConfig extends ServiceMap.Service<
-  AppConfig,
-  {
-    readonly port: Port
-    readonly password: Password
-  }
->()("@tailcode/AppConfig") {
-  static readonly layer = Layer.effect(AppConfig)(
-    Effect.gen(function* () {
-      const config = Config.all({
-        port: Config.schema(Port, "TAILCODE_PORT").pipe(Config.withDefault(() => Port.makeUnsafe(4096))),
-        password: Config.schema(Password, "TAILCODE_PASSWORD").pipe(
-          Config.withDefault(() => Password.makeUnsafe(Redacted.make(""))),
-        ),
-      })
-
-      return yield* config
-    }),
-  ).pipe(Layer.orDie)
-}

package/src/services/errors.ts

@@ -1,14 +0,0 @@
-import { Schema } from "effect"
-
-export class BinaryNotFound extends Schema.TaggedErrorClass<BinaryNotFound>()("BinaryNotFound", {
-  binary: Schema.String,
-}) {}
-
-export class CommandFailed extends Schema.TaggedErrorClass<CommandFailed>()("CommandFailed", {
-  command: Schema.String,
-  message: Schema.String,
-}) {}
-
-export class HealthCheckFailed extends Schema.TaggedErrorClass<HealthCheckFailed>()("HealthCheckFailed", {
-  message: Schema.String,
-}) {}

package/src/services/opencode.ts

@@ -1,108 +0,0 @@
-import { Duration, Effect, Layer, PlatformError, Redacted, Schedule, ServiceMap } from "effect"
-import type { ChildProcessHandle } from "effect/unstable/process/ChildProcessSpawner"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { BinaryNotFound, HealthCheckFailed } from "./errors.js"
-import { trim } from "../qr.js"
-import { spawnInScope, streamToAppender } from "./process.js"
-
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-
-export class OpenCode extends ServiceMap.Service<
-  OpenCode,
-  {
-    /** Start local OpenCode server and wait until health endpoint responds. */
-    readonly start: (
-      port: number,
-      password: string | Redacted.Redacted<string>,
-      append: (line: string) => void,
-    ) => Effect.Effect<ChildProcessHandle | undefined, BinaryNotFound | HealthCheckFailed | PlatformError.PlatformError>
-  }
->()("@tailcode/OpenCode") {
-  static readonly layer = Layer.effect(OpenCode)(
-    Effect.gen(function* () {
-      const spawner = yield* ChildProcessSpawner
-      const scope = yield* Effect.scope
-
-      /** Start opencode bound to localhost and tie lifecycle to service scope. */
-      const start = Effect.fn("OpenCode.start")(function* (
-        port: number,
-        password: string | Redacted.Redacted<string>,
-        append: (line: string) => void,
-      ) {
-        const alreadyHealthy = yield* Effect.tryPromise({
-          try: () => fetch(`http://127.0.0.1:${port}/global/health`).then((r) => r.ok),
-          catch: () => false as const,
-        }).pipe(Effect.catch(() => Effect.succeed(false)))
-
-        if (alreadyHealthy) {
-          append(`OpenCode server already running on 127.0.0.1:${port}\n`)
-          return undefined
-        }
-
-        const bin = Bun.which("opencode")
-        if (!bin) return yield* new BinaryNotFound({ binary: "opencode" })
-
-        append(`Starting OpenCode server on 127.0.0.1:${port}...\n`)
-
-        const env: Record<string, string> = {}
-        for (const [k, v] of Object.entries(process.env)) {
-          if (v !== undefined) env[k] = v
-        }
-        const passwordValue = Redacted.isRedacted(password) ? Redacted.value(password) : password
-        if (passwordValue) env.OPENCODE_SERVER_PASSWORD = passwordValue
-
-        const handle = yield* spawnInScope(
-          spawner,
-          scope,
-          bin,
-          ["serve", "--hostname", "127.0.0.1", "--port", String(port)],
-          {
-            env,
-            extendEnv: false,
-          },
-        )
-
-        let buffer = ""
-        yield* Effect.forkIn(
-          streamToAppender(handle.all, (text) => {
-            buffer = trim(buffer + text, 8000)
-            append(text)
-          }),
-          scope,
-        )
-
-        const checkHealth = Effect.tryPromise({
-          try: () =>
-            fetch(`http://127.0.0.1:${port}/global/health`).then((r) => {
-              if (!r.ok) throw new Error("not healthy")
-            }),
-          catch: () => new HealthCheckFailed({ message: "not healthy yet" }),
-        }).pipe(
-          Effect.timeoutOrElse({
-            duration: Duration.seconds(2),
-            onTimeout: () => Effect.fail(new HealthCheckFailed({ message: "health check timeout" })),
-          }),
-        )
-
-        const healthCheckPolicy = Schedule.spaced(Duration.millis(250)).pipe(Schedule.both(Schedule.recurs(40)))
-
-        yield* Effect.retryOrElse(checkHealth, healthCheckPolicy, () =>
-          Effect.gen(function* () {
-            yield* handle.kill().pipe(Effect.ignore)
-            return yield* new HealthCheckFailed({
-              message: `OpenCode server did not become healthy\n${buffer}`,
-            })
-          }),
-        )
-
-        return handle
-      })
-
-      return {
-        start,
-      }
-    }),
-  )
-}

package/src/services/process.ts

@@ -1,52 +0,0 @@
-import { Effect, Scope, Stream } from "effect"
-import * as ChildProcess from "effect/unstable/process/ChildProcess"
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-
-type CommandOptions = Record<string, unknown> | undefined
-
-/** Build a process command with consistent non-interactive IO defaults. */
-export const command = (bin: string, args: string[], options?: CommandOptions) =>
-  ChildProcess.make(bin, args, {
-    ...options,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-
-/** Spawn a process in an existing scope so finalization is tied to that scope. */
-export const spawnInScope = (
-  spawner: ChildProcessSpawner,
-  scope: Scope.Scope,
-  bin: string,
-  args: string[],
-  options?: CommandOptions,
-) => Scope.provide(spawner.spawn(command(bin, args, options)), scope)
-
-/** Run a command to completion and return only its exit code. */
-export const spawnExitCode = (spawner: ChildProcessSpawner, bin: string, args: string[], options?: CommandOptions) =>
-  Effect.scoped(spawner.spawn(command(bin, args, options)).pipe(Effect.flatMap((handle) => handle.exitCode)))
-
-/** Run a command to completion and collect combined stdout/stderr text. */
-export const spawnString = (spawner: ChildProcessSpawner, bin: string, args: string[], options?: CommandOptions) =>
-  Effect.scoped(
-    spawner
-      .spawn(command(bin, args, options))
-      .pipe(Effect.flatMap((handle) => Stream.mkString(Stream.decodeText(handle.all)))),
-  )
-
-/** Forward decoded process output chunks into an append callback. */
-export const streamToAppender = <E, R>(stream: Stream.Stream<Uint8Array, E, R>, append: (line: string) => void) =>
-  Stream.runForEach(stream, (chunk) =>
-    Effect.sync(() => {
-      const text = new TextDecoder().decode(chunk)
-      if (!text) return
-      append(text)
-    }),
-  )
-
-/** Swallow any failure and return void for best-effort cleanup paths. */
-export const ignoreErrors = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  Effect.match(effect, {
-    onFailure: () => undefined,
-    onSuccess: () => undefined,
-  })