@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/system/providers/active-app.ts

@@ -0,0 +1,97 @@
+import type pino from "pino"
+
+import {
+  logNull,
+  noopUnsubscribe,
+  type CommandExecutor,
+  type LinuxDbusBus,
+} from "./shared"
+
+export interface ActiveAppSnapshot {
+  name: string
+  windowTitle: string | null
+  processId: number | null
+}
+
+export interface ActiveAppProvider {
+  getActive(): Promise<ActiveAppSnapshot | null>
+  subscribe(handler: (snapshot: ActiveAppSnapshot | null) => void): () => void
+  stop(): Promise<void>
+}
+
+export const createNullActiveAppProvider = (
+  reason: string,
+  logger?: pino.Logger,
+): ActiveAppProvider => {
+  logNull(logger, "active-app", reason)
+  return {
+    async getActive() {
+      return null
+    },
+    subscribe() {
+      return noopUnsubscribe
+    },
+    async stop() {
+      return
+    },
+  }
+}
+
+export interface CreateActiveAppProviderOptions {
+  readonly platform?: NodeJS.Platform
+  readonly executor?: CommandExecutor
+  readonly dbus?: LinuxDbusBus
+  readonly logger: pino.Logger
+}
+
+export const createActiveAppProvider = async (
+  options: CreateActiveAppProviderOptions,
+): Promise<ActiveAppProvider> => {
+  const platform = options.platform ?? process.platform
+  if (platform === "linux") {
+    if (options.executor === undefined) {
+      return createNullActiveAppProvider(
+        "executor-not-injected",
+        options.logger,
+      )
+    }
+    const { createLinuxActiveAppProvider } = await import("./active-app/linux")
+    return createLinuxActiveAppProvider({
+      executor: options.executor,
+      ...(options.dbus !== undefined ? { dbus: options.dbus } : {}),
+      logger: options.logger,
+    })
+  }
+  if (platform === "darwin") {
+    if (options.executor === undefined) {
+      return createNullActiveAppProvider(
+        "executor-not-injected",
+        options.logger,
+      )
+    }
+    const { createDarwinActiveAppProvider } =
+      await import("./active-app/darwin")
+    return createDarwinActiveAppProvider({
+      executor: options.executor,
+      logger: options.logger,
+    })
+  }
+  if (platform === "win32") {
+    if (options.executor === undefined) {
+      return createNullActiveAppProvider(
+        "executor-not-injected",
+        options.logger,
+      )
+    }
+    const { createWindowsActiveAppProvider } =
+      await import("./active-app/windows")
+    return createWindowsActiveAppProvider({
+      executor: options.executor,
+      logger: options.logger,
+    })
+  }
+  return createNullActiveAppProvider(
+    `platform:${platform}-pending`,
+    options.logger,
+  )
+}

package/src/system/providers/clipboard/darwin.ts

@@ -0,0 +1,65 @@
+import type pino from "pino"
+
+import type { ClipboardProvider } from "../clipboard"
+import { ProviderError } from "../error"
+import type { CommandExecutor } from "../shared"
+import { withTimeout } from "../shared"
+
+export interface CreateDarwinClipboardProviderOptions {
+  readonly executor: CommandExecutor
+  readonly logger: pino.Logger
+  readonly timeoutMs?: number
+}
+
+export const createDarwinClipboardProvider = (
+  options: CreateDarwinClipboardProviderOptions,
+): ClipboardProvider => {
+  const { executor, logger, timeoutMs: timeoutMsOption } = options
+  const timeoutMs = timeoutMsOption ?? 500
+  let disposed = false
+  const stop = async (): Promise<void> => {
+    disposed = true
+  }
+
+  const writeText = async (text: string): Promise<void> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    const escaped = text.replace(/'/g, "'\\''")
+    try {
+      const result = await withTimeout(
+        executor.run("sh", ["-c", `printf '%s' '${escaped}' | pbcopy`], {
+          timeoutMs,
+        }),
+        timeoutMs + 500,
+      )
+      if (result.exitCode !== 0) {
+        logger.warn({ stderr: result.stderr }, "clipboard: pbcopy failed")
+        throw new ProviderError(
+          "EXEC_FAILED",
+          `clipboard write failed: ${result.stderr || "unknown error"}`,
+        )
+      }
+    } catch (err) {
+      if (err instanceof ProviderError) throw err
+      throw new ProviderError(
+        "EXEC_FAILED",
+        `clipboard write failed: ${err instanceof Error ? err.message : String(err)}`,
+      )
+    }
+  }
+
+  const readText = async (): Promise<string> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    try {
+      const result = await withTimeout(
+        executor.run("pbpaste", [], { timeoutMs }),
+        timeoutMs + 500,
+      )
+      if (result.exitCode === 0) return result.stdout
+    } catch {
+      // ignore
+    }
+    return ""
+  }
+
+  return { writeText, readText, stop }
+}

package/src/system/providers/clipboard/linux.ts

@@ -0,0 +1,163 @@
+import type pino from "pino"
+
+import type { ClipboardProvider } from "../clipboard"
+import { ProviderError } from "../error"
+import type { CommandExecutor } from "../shared"
+import { withTimeout } from "../shared"
+
+export interface CreateLinuxClipboardProviderOptions {
+  readonly executor: CommandExecutor
+  readonly env?: Readonly<Record<string, string>>
+  readonly logger: pino.Logger
+  readonly timeoutMs?: number
+  readonly extraFsProbe?: (tool: string) => boolean
+}
+
+const WL_COPY_TOOL = "wl-copy"
+const WL_PASTE_TOOL = "wl-paste"
+const XCLIP_TOOL = "xclip"
+const XSEL_TOOL = "xsel"
+
+const probeTool = async (
+  executor: CommandExecutor,
+  tool: string,
+  extraFsProbe?: (tool: string) => boolean,
+): Promise<boolean> => {
+  const result = await executor.run("which", [tool])
+  if (result.exitCode === 0 && result.stdout.trim().length > 0) return true
+  // ponytail: fallback when CLI is launched with a stripped PATH (systemd,
+  // launchd, IDE runners) and `which` returns nothing even though wl-copy
+  // is installed at e.g. /usr/bin. Mirror of the requirements.ts probe and
+  // key-macro/linux.ts probeTool.
+  return extraFsProbe?.(tool) === true
+}
+
+const shellQuote = (value: string): string =>
+  `'${value.replace(/'/g, "'\\''")}'`
+
+export const createLinuxClipboardProvider = (
+  options: CreateLinuxClipboardProviderOptions,
+): ClipboardProvider => {
+  const { executor, logger, timeoutMs: timeoutMsOption } = options
+  const timeoutMs = timeoutMsOption ?? 500
+  const isX11 =
+    options.env?.["WAYLAND_DISPLAY"] === undefined &&
+    options.env?.["DISPLAY"] !== undefined
+  const tools = isX11 ? [XCLIP_TOOL, XSEL_TOOL] : [WL_COPY_TOOL]
+  let selectedTool = tools[0]!
+  let disposed = false
+
+  const stop = async (): Promise<void> => {
+    disposed = true
+  }
+
+  const writeText = async (text: string): Promise<void> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    // ponytail: `-o` (paste-once) makes wl-copy exit after the next paste, so
+    // the surrounding `sh -c` pipeline does not wait on a long-lived wl-copy.
+    // The runtime's spawn() already drains stdio on 'exit', but the shell
+    // here waits for every child in the pipeline — without `-o`, wl-copy
+    // stays alive maintaining clipboard ownership and the pipe never closes.
+    const command = isX11
+      ? selectedTool === XSEL_TOOL
+        ? `printf '%s' ${shellQuote(text)} | ${XSEL_TOOL} --clipboard --input`
+        : `printf '%s' ${shellQuote(text)} | ${XCLIP_TOOL} -selection clipboard`
+      : `printf '%s' ${shellQuote(text)} | ${WL_COPY_TOOL} -o`
+    const startedAt = Date.now()
+    logger.info(
+      { step: "clipboard.writeText", command, textPreview: text.slice(0, 24) },
+      "clipboard: invoking tool",
+    )
+    const result = await withTimeout(
+      executor.run("sh", ["-c", command]),
+      timeoutMs + 2500,
+    )
+    logger.info(
+      {
+        step: "clipboard.writeText",
+        exitCode: result.exitCode,
+        stderr: result.stderr.trim(),
+        elapsedMs: Date.now() - startedAt,
+      },
+      "clipboard: tool returned",
+    )
+    if (result.exitCode !== 0) {
+      logger.warn({ stderr: result.stderr.trim() }, "clipboard: write failed")
+      throw new ProviderError(
+        "EXEC_FAILED",
+        `clipboard write failed with ${tools.join(" or ")}: ${result.stderr.trim() || "unknown error"}`,
+      )
+    }
+  }
+
+  const readText = async (): Promise<string> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    try {
+      if (!(await ensureProbed())) return ""
+      const startedAt = Date.now()
+      const result = await withTimeout(
+        isX11
+          ? selectedTool === XSEL_TOOL
+            ? executor.run(XSEL_TOOL, ["--clipboard", "--output"])
+            : executor.run(XCLIP_TOOL, ["-selection", "clipboard", "-out"])
+          : executor.run(WL_PASTE_TOOL, []),
+        timeoutMs + 2500,
+      )
+      logger.info(
+        {
+          step: "clipboard.readText",
+          exitCode: result.exitCode,
+          stdoutPreview: result.stdout.slice(0, 32),
+          elapsedMs: Date.now() - startedAt,
+        },
+        "clipboard: wl-paste returned",
+      )
+      if (result.exitCode !== 0) return ""
+      return result.stdout
+    } catch {
+      return ""
+    }
+  }
+
+  let _probeDone = false
+  let _probeOk = false
+  const ensureProbed = async (): Promise<boolean> => {
+    if (_probeDone) return _probeOk
+    _probeOk = false
+    for (const tool of tools) {
+      if (await probeTool(executor, tool, options.extraFsProbe)) {
+        selectedTool = tool
+        _probeOk = true
+        break
+      }
+    }
+    _probeDone = true
+    if (!_probeOk) {
+      logger.warn(
+        { tools },
+        "clipboard tool not found on PATH; clipboard will throw ProviderError",
+      )
+    }
+    return _probeOk
+  }
+
+  // Eager probe so a missing tool surfaces at init time.
+  void ensureProbed()
+
+  return {
+    writeText: async (text: string) => {
+      const ok = await ensureProbed()
+      if (!ok) {
+        throw new ProviderError(
+          "NOT_AVAILABLE",
+          isX11
+            ? "none of xclip or xsel found on PATH"
+            : "wl-copy not found on PATH; install the wl-clipboard package",
+        )
+      }
+      await writeText(text)
+    },
+    readText,
+    stop,
+  }
+}

package/src/system/providers/clipboard/windows.ts

@@ -0,0 +1,94 @@
+import type pino from "pino"
+
+import type { ClipboardProvider } from "../clipboard"
+import { ProviderError } from "../error"
+import type { CommandExecutor } from "../shared"
+import { withTimeout } from "../shared"
+
+export interface CreateWindowsClipboardProviderOptions {
+  readonly executor: CommandExecutor
+  readonly logger: pino.Logger
+  readonly timeoutMs?: number
+}
+
+const encodePSCommand = (script: string): string => {
+  const buf = Buffer.from(script, "utf16le")
+  return buf.toString("base64")
+}
+
+const escapeForPowerShellSingleQuote = (s: string): string =>
+  s.replace(/'/g, "''")
+
+const escapeForDoubleQuote = (s: string): string =>
+  s.replace(/[\\"$`]/g, "``$&")
+
+export const createWindowsClipboardProvider = (
+  options: CreateWindowsClipboardProviderOptions,
+): ClipboardProvider => {
+  const { executor, logger, timeoutMs: timeoutMsOption } = options
+  const timeoutMs = timeoutMsOption ?? 500
+  let disposed = false
+  const stop = async (): Promise<void> => {
+    disposed = true
+  }
+
+  const runPS = async (script: string): Promise<string> => {
+    const result = await withTimeout(
+      executor.run("powershell", ["-NoProfile", "-Command", script], {
+        timeoutMs,
+      }),
+      timeoutMs + 500,
+    )
+    if (result.exitCode !== 0) {
+      logger.warn({ stderr: result.stderr }, "clipboard: powershell failed")
+      throw new ProviderError(
+        "EXEC_FAILED",
+        `clipboard write failed: ${result.stderr.trim() || "unknown error"}`,
+      )
+    }
+    return result.stdout
+  }
+
+  const writeText = async (text: string): Promise<void> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    // ponytail: -EncodedCommand avoids shell/interpolation entirely. The text
+    // is embedded inside a base64 UTF-16LE blob PowerShell parses as a script.
+    const escaped = escapeForDoubleQuote(text)
+    const psValue = `'${escapeForPowerShellSingleQuote(escaped)}'`
+    const script = `Set-Clipboard -Value ${psValue}`
+    const encoded = encodePSCommand(script)
+    const result = await withTimeout(
+      executor.run("powershell", ["-NoProfile", "-EncodedCommand", encoded], {
+        timeoutMs,
+      }),
+      timeoutMs + 500,
+    )
+    if (result.exitCode !== 0) {
+      logger.warn({ stderr: result.stderr }, "clipboard: powershell failed")
+      throw new ProviderError(
+        "EXEC_FAILED",
+        `clipboard write failed: ${result.stderr.trim() || "unknown error"}`,
+      )
+    }
+  }
+
+  const readText = async (): Promise<string> => {
+    if (disposed) throw new Error("Clipboard provider is disposed")
+    try {
+      const result = await withTimeout(
+        executor.run(
+          "powershell",
+          ["-NoProfile", "-Command", "Get-Clipboard"],
+          { timeoutMs },
+        ),
+        timeoutMs + 500,
+      )
+      if (result.exitCode === 0) return result.stdout
+    } catch {
+      // ignore
+    }
+    return ""
+  }
+
+  return { writeText, readText, stop }
+}

package/src/system/providers/clipboard.ts

@@ -0,0 +1,84 @@
+import type pino from "pino"
+
+import { ProviderError } from "./error"
+
+import { createDarwinClipboardProvider } from "./clipboard/darwin"
+import { createLinuxClipboardProvider } from "./clipboard/linux"
+import { createWindowsClipboardProvider } from "./clipboard/windows"
+import { type CommandExecutor } from "./shared"
+
+export interface ClipboardProvider {
+  writeText(text: string): Promise<void>
+  readText(): Promise<string>
+  stop(): Promise<void>
+}
+
+export const createNullClipboardProvider = (
+  logger?: pino.Logger,
+): ClipboardProvider => {
+  if (logger) {
+    logger.warn(
+      { provider: "clipboard" },
+      "OS clipboard provider unavailable, using null provider",
+    )
+  }
+  return {
+    async writeText(_text: string): Promise<void> {
+      throw new ProviderError(
+        "NOT_AVAILABLE",
+        "Clipboard provider not available on this platform",
+      )
+    },
+    async readText(): Promise<string> {
+      throw new ProviderError(
+        "NOT_AVAILABLE",
+        "Clipboard provider not available on this platform",
+      )
+    },
+    async stop() {
+      return
+    },
+  }
+}
+
+export interface CreateClipboardProviderOptions {
+  readonly executor: CommandExecutor
+  readonly platform?: NodeJS.Platform
+  readonly env?: Readonly<Record<string, string>>
+  readonly logger: pino.Logger
+  readonly extraFsProbe?: (tool: string) => boolean
+}
+
+export const createClipboardProvider = (
+  options: CreateClipboardProviderOptions,
+): ClipboardProvider => {
+  const logger = options.logger.child({ component: "clipboard" })
+  const platform = options.platform ?? process.platform
+  if (platform === "linux") {
+    return createLinuxClipboardProvider({
+      executor: options.executor,
+      ...(options.env !== undefined ? { env: options.env } : {}),
+      logger: options.logger,
+      ...(options.extraFsProbe !== undefined
+        ? { extraFsProbe: options.extraFsProbe }
+        : {}),
+    })
+  }
+  if (platform === "darwin") {
+    return createDarwinClipboardProvider({
+      executor: options.executor,
+      logger: options.logger,
+    })
+  }
+  if (platform === "win32") {
+    return createWindowsClipboardProvider({
+      executor: options.executor,
+      logger: options.logger,
+    })
+  }
+  void createNullClipboardProvider(options.logger)
+  throw new ProviderError(
+    "UNSUPPORTED_PLATFORM",
+    `Clipboard provider not implemented for platform '${platform}' in this build`,
+  )
+}

package/src/system/providers/error.ts

@@ -0,0 +1,16 @@
+export type ProviderErrorCode =
+  | "NOT_AVAILABLE"
+  | "TIMEOUT"
+  | "EXEC_FAILED"
+  | "PARSE_ERROR"
+  | "UNSUPPORTED_PLATFORM"
+
+export class ProviderError extends Error {
+  readonly code: ProviderErrorCode
+
+  constructor(code: ProviderErrorCode, message: string) {
+    super(message)
+    this.name = "ProviderError"
+    this.code = code
+  }
+}