k0-board 0.1.0

package/platform/win32/service.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { runQuiet, which } from '../shared/run.js'
+import { ps, psq } from './powershell.js'
+
+/**
+ * Starting k0 at login on Windows.
+ *
+ * A scheduled task, not a Windows service. A service runs in session 0, isolated from every
+ * desktop — which would leave k0 unable to open a terminal window or see one, the two things
+ * it exists to do. A logon-triggered task runs as you, in your session, which is what is
+ * wanted. It also needs no elevation to create.
+ */
+
+const SCHTASKS = () => which('schtasks')
+
+export const SERVER_TASK = 'k0 server'
+export const TRAY_TASK = 'k0 tray'
+
+function taskXml({ command, args, port, workingDirectory }) {
+  const escape = (s) =>
+    String(s).replace(/[<>&'"]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', "'": '&apos;', '"': '&quot;' })[c])
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>k0 — the board that drives your Claude Code sessions</Description></RegistrationInfo>
+  <Triggers><LogonTrigger><Enabled>true</Enabled></LogonTrigger></Triggers>
+  <Principals><Principal id="Author"><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT1M</Interval><Count>3</Count></RestartOnFailure>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${escape(command)}</Command>
+      <Arguments>${escape(args)}</Arguments>
+      <WorkingDirectory>${escape(workingDirectory)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`.replace('<Actions', `<!-- K0_PORT=${escape(String(port))} --><Actions`)
+}
+
+async function register(name, xml, tmpDir) {
+  const file = path.join(tmpDir, `${name.replace(/\s+/g, '-')}.xml`)
+  // Task Scheduler insists on UTF-16 for imported task files.
+  fs.writeFileSync(file, xml, 'utf16le')
+  await runQuiet(SCHTASKS(), ['/Delete', '/TN', name, '/F'])
+  await runQuiet(SCHTASKS(), ['/Create', '/TN', name, '/XML', file])
+  fs.unlinkSync(file)
+}
+
+export async function install({ node, entry, port, logDir, tray, appDir }) {
+  if (!SCHTASKS()) throw new Error('k0 could not find schtasks.exe, which it needs to start at login.')
+  fs.mkdirSync(logDir, { recursive: true })
+
+  // K0_PORT reaches the task through the user environment rather than the task XML, which has
+  // no way to carry environment variables of its own.
+  await ps(`[Environment]::SetEnvironmentVariable('K0_PORT', ${psq(String(port))}, 'User')`)
+
+  await register(
+    SERVER_TASK,
+    taskXml({ command: node, args: `"${entry}"`, port, workingDirectory: appDir }),
+    logDir
+  )
+  await runQuiet(SCHTASKS(), ['/Run', '/TN', SERVER_TASK])
+
+  if (tray && fs.existsSync(tray)) {
+    const shell = which('pwsh') || which('powershell')
+    await register(
+      TRAY_TASK,
+      taskXml({
+        command: shell,
+        args: `-NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "${tray}"`,
+        port,
+        workingDirectory: appDir,
+      }),
+      logDir
+    )
+    await runQuiet(SCHTASKS(), ['/Run', '/TN', TRAY_TASK])
+  }
+}
+
+export async function uninstall() {
+  for (const name of [SERVER_TASK, TRAY_TASK]) {
+    await runQuiet(SCHTASKS(), ['/End', '/TN', name])
+    await runQuiet(SCHTASKS(), ['/Delete', '/TN', name, '/F'])
+  }
+}
+
+export async function restart() {
+  await runQuiet(SCHTASKS(), ['/End', '/TN', SERVER_TASK])
+  await runQuiet(SCHTASKS(), ['/Run', '/TN', SERVER_TASK])
+}
+
+export async function status() {
+  const out = await runQuiet(SCHTASKS(), ['/Query', '/TN', SERVER_TASK, '/FO', 'LIST'])
+  return { running: /Running/i.test(out) }
+}
+
+export const describe = () => [
+  { path: `Task Scheduler → ${SERVER_TASK}`, what: 'a scheduled task that starts k0 when you log in' },
+  { path: `Task Scheduler → ${TRAY_TASK}`, what: 'a scheduled task for the tray icon' },
+  { path: 'User environment variable K0_PORT', what: 'the port k0 listens on' },
+]
+
+export const capabilities = () => ({ autostart: !!SCHTASKS() })

package/platform/win32/shell.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { runQuiet, runSyncQuiet, which } from '../shared/run.js'
+
+const EXPLORER = () => which('explorer') || 'explorer.exe'
+
+/** `explorer /select,` opens the folder with the file already highlighted. */
+export const revealInFileManager = (abs) => runQuiet(EXPLORER(), [`/select,${path.normalize(abs)}`])
+
+export const openBrowser = (url) => runQuiet('cmd', ['/c', 'start', '', url])
+
+const programFiles = [
+  process.env['PROGRAMFILES'],
+  process.env['PROGRAMFILES(X86)'],
+  process.env.LOCALAPPDATA,
+].filter(Boolean)
+
+const CHROME_SUFFIXES = [
+  ['Google', 'Chrome', 'Application', 'chrome.exe'],
+  ['Chromium', 'Application', 'chrome.exe'],
+  ['BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'],
+  ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+]
+
+export function findChrome() {
+  for (const base of programFiles) {
+    for (const suffix of CHROME_SUFFIXES) {
+      const candidate = path.join(base, ...suffix)
+      if (fs.existsSync(candidate)) return candidate
+    }
+  }
+  return which('chrome') || which('msedge') || null
+}
+
+/**
+ * Directories under the user's profile that are never projects. Windows keeps its own state
+ * in the first three and the shell folders in the rest; unlike macOS these are not localised
+ * on disk, whatever File Explorer chooses to display.
+ */
+export const homeSkipList = () =>
+  new Set([
+    'AppData', 'Application Data', 'Local Settings',
+    'Desktop', 'Documents', 'Downloads', 'Music', 'Pictures', 'Videos',
+    'Favorites', 'Links', 'Contacts', 'Searches', 'Saved Games', 'OneDrive',
+  ])
+
+let claudeBin = null
+
+export function findClaude() {
+  if (claudeBin) return claudeBin
+  const candidates = [
+    path.join(os.homedir(), '.local', 'bin', 'claude.exe'),
+    path.join(os.homedir(), '.local', 'bin', 'claude.cmd'),
+    path.join(process.env.APPDATA || '', 'npm', 'claude.cmd'),
+  ]
+  for (const c of candidates) if (c && fs.existsSync(c)) return (claudeBin = c)
+  const fromPath = which('claude')
+  if (fromPath) return (claudeBin = fromPath)
+  claudeBin = runSyncQuiet('cmd', ['/c', 'where claude']).trim().split('\n')[0] || 'claude'
+  return claudeBin
+}
+
+export const capabilities = () => ({ revealInFileManager: true })

package/platform/win32/terminal.js

@@ -0,0 +1,209 @@
+import { spawn } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+import { which } from '../shared/run.js'
+import { ps, psJson, psq } from './powershell.js'
+
+/**
+ * Terminals on Windows.
+ *
+ * This is the adapter that gives something up, and it is worth being plain about what.
+ *
+ * Windows has no way for one process to read what is printed inside another's console. On
+ * macOS `readScreen` is how k0 knows Claude Code's interface has finished drawing and is
+ * ready to receive a prompt; here there is nothing to ask, so k0 waits a fixed moment
+ * instead. That is a guess, and a slow machine can beat it — which is why the capability is
+ * reported as missing rather than quietly approximated.
+ *
+ * Everything else survives. A prompt can be placed without being sent, because Windows lets
+ * any process put text on the clipboard and send a Ctrl+V to the foreground window without
+ * asking for a special permission — the thing macOS needs Accessibility for. Windows can be
+ * moved, resized and raised through user32, found by the unique title k0 gives each one.
+ *
+ * If you run Claude Code inside WSL, run k0 inside WSL too: there it is simply the Linux
+ * build, tmux and all, with nothing given up.
+ */
+
+const WT = () => which('wt')
+const POWERSHELL_BIN = () => which('pwsh') || which('powershell')
+
+/** The user32 declarations every window operation here needs, added once per PowerShell run. */
+const USER32 = `
+Add-Type -Namespace K0 -Name Win -MemberDefinition @'
+  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr h);
+  [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr h, int c);
+  [DllImport("user32.dll")] public static extern bool MoveWindow(IntPtr h, int x, int y, int w, int t, bool r);
+'@ -ErrorAction SilentlyContinue
+`
+
+/**
+ * The handle k0 stores is the window title, because it is the only identifier that survives
+ * the launch: `wt.exe` hands its arguments to an already-running Windows Terminal and exits,
+ * so its own process id says nothing about the window that appeared.
+ */
+const handleFor = (title) => `k0-${randomUUID().slice(0, 8)} ${title}`.trim()
+
+const findWindow = (handle) =>
+  `Get-Process | Where-Object { $_.MainWindowTitle -like ${psq('*' + handle + '*')} } | Select-Object -First 1`
+
+export async function open({ command, title }) {
+  const handle = handleFor(title)
+  const shell = POWERSHELL_BIN()
+  if (!shell) throw new Error('k0 could not find PowerShell, which it needs to open terminals on Windows.')
+
+  // The title is set from inside the session rather than passed to the terminal, because it
+  // has to be there whichever terminal actually opens — Windows Terminal, the old console
+  // host, or whatever the user has set as default.
+  const inner = `$host.UI.RawUI.WindowTitle = ${psq(handle)}; ${command}`
+  const wt = WT()
+  const [file, args] = wt
+    ? [wt, ['new-tab', '--title', handle, shell, '-NoProfile', '-NoLogo', '-NoExit', '-Command', inner]]
+    : [shell, ['-NoProfile', '-NoLogo', '-NoExit', '-Command', inner]]
+
+  const child = spawn(file, args, { stdio: 'ignore', detached: true, windowsHide: false })
+  child.unref()
+  return handle
+}
+
+/**
+ * Windows Terminal owns its tab titles and does not take instructions about them from
+ * outside, so a card renamed after its session started keeps the old name in the title bar
+ * until the session is restarted. Reported as unavailable rather than failing silently.
+ */
+export async function setTitle() {
+  return false
+}
+
+export async function focus(handle) {
+  if (!handle) return { ok: false, error: 'This card has no terminal window of its own' }
+  const found = await psJson(
+    `${USER32}
+     $p = ${findWindow(handle)}
+     if ($p) { [K0.Win]::ShowWindow($p.MainWindowHandle, 9) | Out-Null
+               [K0.Win]::SetForegroundWindow($p.MainWindowHandle) | Out-Null
+               @{ ok = $true } } else { @{ ok = $false } }`,
+    { ok: false }
+  )
+  return found?.ok ? { ok: true } : { ok: false, error: 'That window is gone' }
+}
+
+export async function relayout(handles) {
+  let touched = 0
+  for (const handle of handles || []) {
+    const ok = await psJson(
+      `${USER32}
+       Add-Type -AssemblyName System.Windows.Forms -ErrorAction SilentlyContinue
+       $area = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
+       $w = [int]($area.Width * 0.86); $h = [int]($area.Height * 0.86)
+       $x = $area.X + [int](($area.Width - $w) / 2); $y = $area.Y + [int](($area.Height - $h) / 2)
+       $p = ${findWindow(handle)}
+       if ($p) { [K0.Win]::MoveWindow($p.MainWindowHandle, $x, $y, $w, $h, $true) | Out-Null; @{ ok = $true } }
+       else { @{ ok = $false } }`,
+      { ok: false }
+    )
+    if (ok?.ok) touched++
+  }
+  return { touched }
+}
+
+/** Font size lives in the terminal's own profile, which k0 will not rewrite. */
+export async function setFont() {
+  return { touched: 0 }
+}
+
+export async function defaultFontSize() {
+  return 12
+}
+
+/** Nothing to read: see the note at the top of this file. */
+export async function readScreen() {
+  return null
+}
+
+/**
+ * Put the prompt in front of you without sending it: clipboard, then a Ctrl+V into the
+ * window once it is in the foreground. SendKeys needs no elevation and no special permission
+ * on Windows, which makes this the one place where Windows has an easier time than macOS.
+ */
+export async function paste(text, handle) {
+  try {
+    await ps(
+      `${USER32}
+       Add-Type -AssemblyName System.Windows.Forms
+       $previous = ''
+       try { $previous = Get-Clipboard -Raw } catch {}
+       Set-Clipboard -Value ${psq(text)}
+       $p = ${findWindow(handle)}
+       if (-not $p) { throw 'window not found' }
+       [K0.Win]::ShowWindow($p.MainWindowHandle, 9) | Out-Null
+       [K0.Win]::SetForegroundWindow($p.MainWindowHandle) | Out-Null
+       Start-Sleep -Milliseconds 250
+       [System.Windows.Forms.SendKeys]::SendWait('^v')
+       Start-Sleep -Milliseconds 250
+       if ($previous) { Set-Clipboard -Value $previous }`,
+      { timeout: 15000 }
+    )
+    return { pasted: true }
+  } catch (err) {
+    return { pasted: false, error: String(err.stderr || err.message).trim() }
+  }
+}
+
+/**
+ * The fallback: type the prompt and send it. Same trade as on macOS — the session starts on
+ * its own instead of waiting for you — and used only when pasting failed.
+ */
+export async function type(text, handle) {
+  try {
+    await ps(
+      `${USER32}
+       Add-Type -AssemblyName System.Windows.Forms
+       Set-Clipboard -Value ${psq(text)}
+       $p = ${findWindow(handle)}
+       if (-not $p) { throw 'window not found' }
+       [K0.Win]::SetForegroundWindow($p.MainWindowHandle) | Out-Null
+       Start-Sleep -Milliseconds 250
+       [System.Windows.Forms.SendKeys]::SendWait('^v')
+       Start-Sleep -Milliseconds 250
+       [System.Windows.Forms.SendKeys]::SendWait('{ENTER}')`,
+      { timeout: 15000 }
+    )
+    return { written: true }
+  } catch (err) {
+    return { written: false, error: String(err.stderr || err.message).trim() }
+  }
+}
+
+export async function close({ handle, pid }) {
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM')
+      for (let i = 0; i < 20; i++) {
+        await new Promise((r) => setTimeout(r, 100))
+        try {
+          process.kill(pid, 0)
+        } catch {
+          break
+        }
+      }
+    } catch {
+      /* already gone */
+    }
+  }
+  if (!handle) return { closed: false }
+  const res = await psJson(
+    `$p = ${findWindow(handle)}
+     if ($p) { $p.CloseMainWindow() | Out-Null; @{ ok = $true } } else { @{ ok = $false } }`,
+    { ok: false }
+  )
+  return { closed: !!res?.ok }
+}
+
+export const capabilities = () => ({
+  windows: !!POWERSHELL_BIN(),
+  font: false,
+  readScreen: false,
+  pasteWithoutSending: !!POWERSHELL_BIN(),
+  title: false,
+})
+
+export { powershellCommand as buildCommand } from '../shared/command.js'

package/platform/win32/tray.ps1

@@ -0,0 +1,159 @@
+# k0's tray icon for Windows.
+#
+# The counterpart of menubar/K0MenuBar.swift and platform/linux/tray.py, and deliberately the
+# same shape: poll /api/status every couple of seconds, tint a small square with the colour of
+# the most urgent session, and put the sessions that are waiting for you at the top of the
+# menu so one click brings the right terminal back.
+#
+# WinForms' NotifyIcon is used because it is part of .NET Framework, which is on every Windows
+# install: nothing to download, nothing to compile, no dependency added to a project that has
+# none. The icon is drawn at runtime rather than shipped as a file, for the same reason.
+
+param([int]$Port = $(if ($env:K0_PORT) { [int]$env:K0_PORT } else { 4319 }))
+
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$Base = "http://127.0.0.1:$Port"
+
+# The same colours and the same order of urgency as the board. ASK first because a question
+# blocks everything behind it; COMPLETED never gets here.
+$Urgency = @('ASK', 'PLANNED', 'IDLE', 'WORKING', 'PLANNING')
+$Colours = @{
+  ASK      = @(232, 106, 51)
+  PLANNED  = @(108, 142, 191)
+  IDLE     = @(224, 192, 74)
+  WORKING  = @(91, 168, 106)
+  PLANNING = @(142, 124, 195)
+  quiet    = @(154, 154, 154)
+  down     = @(176, 80, 80)
+}
+$Labels = @{
+  ASK = 'Needs answer'; PLANNED = 'Needs approval'; IDLE = 'Your turn'
+  WORKING = 'Working'; PLANNING = 'Planning'
+}
+$Modes = [ordered]@{ sleep = 'Sleep'; away = 'Away'; nerd = 'Nerd'; driving = 'Driving' }
+
+$script:IconCache = @{}
+$script:Seen = @{}
+$script:FirstPass = $true
+$script:Mode = $null
+
+function Get-K0Icon([string]$State) {
+  if ($script:IconCache.ContainsKey($State)) { return $script:IconCache[$State] }
+  $rgb = $Colours[$State]
+  if (-not $rgb) { $rgb = $Colours['quiet'] }
+  $bitmap = New-Object System.Drawing.Bitmap 16, 16
+  $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+  $brush = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb($rgb[0], $rgb[1], $rgb[2]))
+  $graphics.FillRectangle($brush, 1, 1, 14, 14)
+  $graphics.Dispose()
+  $icon = [System.Drawing.Icon]::FromHandle($bitmap.GetHicon())
+  $script:IconCache[$State] = $icon
+  return $icon
+}
+
+function Invoke-K0([string]$Path, $Body) {
+  try {
+    if ($null -ne $Body) {
+      $json = $Body | ConvertTo-Json -Compress
+      return Invoke-RestMethod -Uri ($Base + $Path) -Method Post -Body $json `
+        -ContentType 'application/json' -Headers @{ Origin = $Base } -TimeoutSec 3
+    }
+    return Invoke-RestMethod -Uri ($Base + $Path) -Method Get -Headers @{ Origin = $Base } -TimeoutSec 3
+  } catch {
+    return $null
+  }
+}
+
+$notify = New-Object System.Windows.Forms.NotifyIcon
+$notify.Icon = Get-K0Icon 'quiet'
+$notify.Text = 'k0'
+$notify.Visible = $true
+$menu = New-Object System.Windows.Forms.ContextMenuStrip
+$notify.ContextMenuStrip = $menu
+
+function Add-K0Item($Text, $Action, [bool]$Enabled = $true) {
+  $item = New-Object System.Windows.Forms.ToolStripMenuItem
+  $item.Text = $Text
+  $item.Enabled = $Enabled -and ($null -ne $Action)
+  if ($null -ne $Action) { $item.Add_Click($Action) | Out-Null }
+  $menu.Items.Add($item) | Out-Null
+  return $item
+}
+
+function Update-K0Menu($Waiting, [bool]$Down) {
+  $menu.Items.Clear()
+  if ($Down) {
+    Add-K0Item 'Server not responding' $null $false | Out-Null
+  } elseif (-not $Waiting -or $Waiting.Count -eq 0) {
+    Add-K0Item 'Nothing waiting for you' $null $false | Out-Null
+  } else {
+    foreach ($card in $Waiting) {
+      $label = "$($Labels[$card.status]) - $($card.title)"
+      $id = $card.id
+      Add-K0Item $label ([System.EventHandler]{ Invoke-K0 "/api/card/$id/focus" @{} | Out-Null }.GetNewClosure()) | Out-Null
+    }
+  }
+
+  $menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
+  foreach ($key in $Modes.Keys) {
+    $value = $key
+    $item = Add-K0Item $Modes[$key] ([System.EventHandler]{
+        if ($script:Mode -ne $value) { Invoke-K0 '/api/mode' @{ mode = $value } | Out-Null }
+      }.GetNewClosure())
+    $item.Checked = ($script:Mode -eq $value)
+  }
+
+  $menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
+  Add-K0Item 'Dashboard' ([System.EventHandler]{ Start-Process $Base }) | Out-Null
+  Add-K0Item 'Restart server' ([System.EventHandler]{
+      schtasks /End /TN 'k0 server' | Out-Null; schtasks /Run /TN 'k0 server' | Out-Null
+    }) | Out-Null
+  Add-K0Item 'Quit' ([System.EventHandler]{
+      $notify.Visible = $false; [System.Windows.Forms.Application]::Exit()
+    }) | Out-Null
+}
+
+# Notify about cards that have just started waiting, not about every one on every pass.
+function Show-K0Notifications($Waiting) {
+  $now = @{}
+  foreach ($card in $Waiting) { $now["$($card.id):$($card.status)"] = $true }
+  if (-not $script:FirstPass) {
+    foreach ($card in $Waiting) {
+      $key = "$($card.id):$($card.status)"
+      if (-not $script:Seen.ContainsKey($key)) {
+        $notify.BalloonTipTitle = $Labels[$card.status]
+        $notify.BalloonTipText = $card.title
+        $notify.ShowBalloonTip(4000)
+      }
+    }
+  }
+  $script:Seen = $now
+  $script:FirstPass = $false
+}
+
+$timer = New-Object System.Windows.Forms.Timer
+$timer.Interval = 2000
+$timer.Add_Tick({
+    $status = Invoke-K0 '/api/status'
+    if ($null -eq $status) {
+      $notify.Icon = Get-K0Icon 'down'
+      $notify.Text = 'k0: server not responding'
+      Update-K0Menu @() $true
+      return
+    }
+    $waiting = @($status.waiting)
+    $script:Mode = $status.mode
+    $state = if ($status.urgent) { $status.urgent } else { 'quiet' }
+    $notify.Icon = Get-K0Icon $state
+    $notify.Text = if ($Labels[$state]) { $Labels[$state] } else { 'k0 - nothing waiting for you' }
+    Update-K0Menu $waiting $false
+    Show-K0Notifications $waiting
+  })
+$timer.Start()
+
+Update-K0Menu @() $true
+[System.Windows.Forms.Application]::Run()
+$notify.Visible = $false