@kitlangton/tailcode 0.2.3 → 0.2.5

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,
-  })

package/src/services/tailscale.ts

@@ -1,308 +0,0 @@
-import { Duration, Effect, Layer, Option, PlatformError, Schedule, Schema, Scope, ServiceMap } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { BinaryNotFound, CommandFailed } from "./errors.js"
-import { parseURL, renderQR, trim } from "../qr.js"
-import { ignoreErrors, spawnExitCode, spawnString, spawnInScope, streamToAppender } from "./process.js"
-
-// ---------------------------------------------------------------------------
-// Parsing helpers
-// ---------------------------------------------------------------------------
-
-function parseConflictPort(value: string) {
-  const match = value.match(/listener already exists for port\s+(\d+)/i)
-  return match ? Number(match[1]) : undefined
-}
-
-type ServeMapping = {
-  readonly url: string
-  readonly proxy: string | undefined
-}
-
-const ServeHandlerSchema = Schema.Struct({
-  Proxy: Schema.optional(Schema.String),
-})
-
-const ServeHandlersSchema = Schema.Record(Schema.String, ServeHandlerSchema)
-
-const ServeEndpointSchema = Schema.Struct({
-  Handlers: Schema.optional(ServeHandlersSchema),
-})
-
-const ServeWebSchema = Schema.Record(Schema.String, ServeEndpointSchema)
-
-const ServeNodeSchema = Schema.Struct({
-  Web: Schema.optional(ServeWebSchema),
-})
-
-const ServeNodesSchema = Schema.Record(Schema.String, ServeNodeSchema)
-
-const ServeStatusSchema = Schema.Struct({
-  Web: Schema.optional(ServeWebSchema),
-  Foreground: Schema.optional(ServeNodesSchema),
-  Background: Schema.optional(ServeNodesSchema),
-})
-
-type ServeWeb = Schema.Schema.Type<typeof ServeWebSchema>
-type ServeStatus = Schema.Schema.Type<typeof ServeStatusSchema>
-
-const decodeServeStatus = Schema.decodeUnknownSync(ServeStatusSchema)
-
-function appendMappingsFromWeb(web: ServeWeb | undefined, mappings: Array<ServeMapping>) {
-  if (!web) return
-
-  for (const [host, endpoint] of Object.entries(web)) {
-    const handlers = endpoint.Handlers
-    if (!handlers || Object.keys(handlers).length === 0) {
-      mappings.push({ url: `https://${host}`, proxy: undefined })
-      continue
-    }
-
-    for (const [path, handler] of Object.entries(handlers)) {
-      const normalizedPath = path === "/" ? "" : String(path)
-      mappings.push({
-        url: `https://${host}${normalizedPath}`,
-        proxy: handler.Proxy,
-      })
-    }
-  }
-}
-
-function parseServeMappings(raw: string): ReadonlyArray<ServeMapping> {
-  const start = raw.indexOf("{")
-  if (start === -1) return []
-
-  const jsonText = raw.slice(start)
-
-  let status: ServeStatus
-  try {
-    status = decodeServeStatus(JSON.parse(jsonText))
-  } catch {
-    return []
-  }
-
-  const mappings: Array<ServeMapping> = []
-
-  appendMappingsFromWeb(status.Web, mappings)
-  for (const node of Object.values(status.Foreground ?? {})) {
-    appendMappingsFromWeb(node.Web, mappings)
-  }
-  for (const node of Object.values(status.Background ?? {})) {
-    appendMappingsFromWeb(node.Web, mappings)
-  }
-
-  return mappings
-}
-
-function pickRemoteUrl(statusOutput: string, target: string) {
-  const statusMappings = parseServeMappings(statusOutput)
-  const exact = statusMappings.find((item) => item.proxy === target)
-  if (exact) return exact.url
-  if (statusMappings.length > 0) return statusMappings[0]!.url
-  return undefined
-}
-
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-
-export class Tailscale extends ServiceMap.Service<
-  Tailscale,
-  {
-    /** Ensure Tailscale is connected; prompts login when disconnected. */
-    readonly ensure: (
-      append: (line: string) => void,
-    ) => Effect.Effect<string, BinaryNotFound | CommandFailed | PlatformError.PlatformError>
-    /** Publish local OpenCode port via tailscale serve and return remote URL. */
-    readonly publish: (
-      bin: string,
-      port: number,
-      append: (line: string) => void,
-    ) => Effect.Effect<string, CommandFailed | PlatformError.PlatformError>
-  }
->()("@tailcode/Tailscale") {
-  static readonly layer = Layer.effect(Tailscale)(
-    Effect.gen(function* () {
-      const spawner = yield* ChildProcessSpawner
-      const scope = yield* Effect.scope
-
-      const run = (bin: string, args: string[]) => spawnExitCode(spawner, bin, args)
-
-      const runString = (bin: string, args: string[]) => spawnString(spawner, bin, args)
-
-      const readServeStatus = (bin: string) =>
-        runString(bin, ["serve", "status", "--json"]).pipe(Effect.catch(() => Effect.succeed("")))
-
-      const waitForTailnetConnection = (bin: string) =>
-        run(bin, ["ip", "-4"]).pipe(
-          Effect.timeoutOrElse({
-            duration: Duration.seconds(2),
-            onTimeout: () => Effect.fail(new CommandFailed({ command: "tailscale ip", message: "timeout" })),
-          }),
-          Effect.flatMap((code) =>
-            code === 0
-              ? Effect.void
-              : Effect.fail(new CommandFailed({ command: "tailscale ip", message: "not connected yet" })),
-          ),
-        )
-
-      const retryConnectionPolicy = Schedule.spaced(Duration.millis(250)).pipe(Schedule.both(Schedule.recurs(80)))
-
-      const retryPublishPolicy = Schedule.spaced(Duration.millis(500)).pipe(Schedule.both(Schedule.recurs(28)))
-
-      /** Ensure daemon availability and interactive login if needed. */
-      const ensure = Effect.fn("Tailscale.ensure")(function* (append: (line: string) => void) {
-        const bin = Bun.which("tailscale")
-        if (!bin) return yield* new BinaryNotFound({ binary: "tailscale" })
-
-        append("Checking Tailscale connection...\n")
-        const checkCode = yield* run(bin, ["ip", "-4"]).pipe(
-          Effect.timeoutOrElse({
-            duration: Duration.seconds(3),
-            onTimeout: () => Effect.succeed(1),
-          }),
-        )
-        if (checkCode === 0) return bin
-
-        append("Tailscale is not connected. Starting login flow...\n")
-        const login = yield* runString(bin, ["up", "--qr"]).pipe(
-          Effect.timeoutOrElse({
-            duration: Duration.seconds(60),
-            onTimeout: () => Effect.succeed(""),
-          }),
-          Effect.orElseSucceed(() => ""),
-        )
-
-        const loginURL = parseURL(login)
-        if (loginURL) {
-          append(`Open this URL (or scan QR): ${loginURL}\n`)
-          append(renderQR(loginURL) + "\n")
-        } else if (login) {
-          append("Follow the Tailscale login prompts in your terminal.\n")
-          append(trim(login, 4000) + "\n")
-        }
-
-        yield* Effect.retryOrElse(waitForTailnetConnection(bin), retryConnectionPolicy, () =>
-          Effect.fail(
-            new CommandFailed({
-              command: "tailscale ip",
-              message: "Timed out waiting for Tailscale to connect",
-            }),
-          ),
-        )
-
-        return bin
-      })
-
-      /** Publish localhost port into tailnet and register scope cleanup. */
-      const publish = Effect.fn("Tailscale.publish")(function* (
-        bin: string,
-        port: number,
-        append: (line: string) => void,
-      ) {
-        const target = `http://127.0.0.1:${port}`
-
-        const spawnServe = () =>
-          spawnInScope(spawner, scope, bin, ["serve", "--bg", "--yes", "--https", String(port), target])
-
-        const waitForProxy = () => {
-          const pollForProxy = readServeStatus(bin).pipe(
-            Effect.flatMap((status) => {
-              const found = pickRemoteUrl(status, target)
-              if (found) return Effect.succeed(found)
-              return Effect.fail(
-                new CommandFailed({
-                  command: "tailscale serve",
-                  message: "waiting for tailscale serve to register proxy...",
-                }),
-              )
-            }),
-          )
-
-          return Effect.retryOrElse(pollForProxy, retryPublishPolicy, () =>
-            Effect.fail(
-              new CommandFailed({
-                command: "tailscale serve",
-                message: "Timed out waiting for tailscale serve to register proxy",
-              }),
-            ),
-          )
-        }
-
-        const existingStatus = yield* readServeStatus(bin)
-        if (parseServeMappings(existingStatus).some((item) => item.proxy === target)) {
-          const existingUrl = pickRemoteUrl(existingStatus, target)
-          if (existingUrl) {
-            append("Reusing existing tailscale serve listener.\n")
-            return existingUrl
-          }
-        }
-
-        append("Publishing with tailscale serve...\n")
-
-        const handle = yield* spawnServe()
-
-        // Register cleanup as an acquired resource so release is tied atomically
-        // to the current scope even across interruption boundaries.
-        yield* Effect.acquireRelease(Effect.void, () =>
-          ignoreErrors(run(bin, ["serve", "--https", String(port), "off"])),
-        ).pipe(Scope.provide(scope))
-
-        let serveOutput = ""
-        yield* Effect.forkScoped(
-          streamToAppender(handle.all, (text) => {
-            append(text)
-            serveOutput = trim(serveOutput + text, 8000)
-          }),
-        )
-
-        const firstAttempt = yield* waitForProxy().pipe(Effect.option)
-        if (Option.isSome(firstAttempt)) return firstAttempt.value
-
-        const conflictPort = parseConflictPort(serveOutput)
-        if (conflictPort === undefined) {
-          return yield* new CommandFailed({
-            command: "tailscale serve",
-            message: "Timed out waiting for tailscale serve to register proxy",
-          })
-        }
-
-        append(
-          `Port ${conflictPort} is already in use. Turning off existing HTTPS listener on that port and retrying once...\n`,
-        )
-        yield* run(bin, ["serve", "--https", String(port), "off"]).pipe(Effect.ignore)
-
-        serveOutput = ""
-        const retryHandle = yield* spawnServe()
-        yield* Effect.forkScoped(
-          streamToAppender(retryHandle.all, (text) => {
-            append(text)
-            serveOutput = trim(serveOutput + text, 8000)
-          }),
-        )
-
-        const secondAttempt = yield* waitForProxy().pipe(Effect.option)
-        if (Option.isSome(secondAttempt)) return secondAttempt.value
-
-        const retryConflictPort = parseConflictPort(serveOutput)
-        if (retryConflictPort !== undefined) {
-          return yield* new CommandFailed({
-            command: "tailscale serve",
-            message:
-              `Listener already exists for port ${retryConflictPort} and could not be claimed automatically. ` +
-              `Please run 'tailscale serve --https ${port} off' manually and retry.`,
-          })
-        }
-
-        return yield* new CommandFailed({
-          command: "tailscale serve",
-          message: "Timed out waiting for tailscale serve to register proxy",
-        })
-      })
-
-      return {
-        ensure,
-        publish,
-      }
-    }),
-  )
-}

package/src/state.ts

@@ -1,15 +0,0 @@
-import * as Atom from "effect/unstable/reactivity/Atom"
-import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry"
-
-export type Phase = "welcome" | "running" | "done" | "error" | "install"
-export type Step = "idle" | "tailscale" | "opencode" | "publish"
-export type MissingBinary = "" | "tailscale" | "opencode"
-
-export const phase = Atom.make<Phase>("welcome")
-export const step = Atom.make<Step>("idle")
-export const log = Atom.make<string>("")
-export const url = Atom.make("")
-export const error = Atom.make("")
-export const missingBinary = Atom.make<MissingBinary>("")
-
-export const registry = AtomRegistry.make()

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@tsconfig/bun/tsconfig.json",
-  "compilerOptions": {
-    "jsx": "preserve",
-    "jsxImportSource": "@opentui/solid",
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "plugins": [{ "name": "@effect/language-service" }]
-  },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "bin/**/*.ts"]
-}