wt-caddy-status

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import { notRegistered, parseDefined, routesFor, statusText, type Defined, type Route } from './format'
5
6const PANE = 'servers'
7const routes = atom({ plugin: 'wt-caddy-status', key: 'routes' } as const, [])
8const defined = atom({ plugin: 'wt-caddy-status', key: 'defined' } as const, [])
9
10
11let bin = ''
12let lastStatus: string | undefined
13let lastRoutes = ''
14
15// wt-caddy checks which ports listen, so one spawn per refresh gives routes and liveness.
16const refresh = async ($: EngineInterface) => {
17  try {
18    const cwd = await $.session.cwd()
19    const ran = await $.process.run([bin, 'ls', '--json'], { timeoutMs: 5000 })
20    const all = JSON.parse(ran.stdout) as Route[]
21    const mine = routesFor(all, cwd)
22
23    const snapshot = JSON.stringify(mine)
24    if (snapshot !== lastRoutes) {
25      lastRoutes = snapshot
26      await update($, routes, () => mine)
27    }
28
29    const text = statusText(all, cwd)
30    const shown = text === undefined ? undefined : `${text} · /servers`
31    if (shown !== lastStatus) {
32      lastStatus = shown
33      $.ui.status(shown)
34    }
35  } catch {
36    // wt-caddy missing or registry unreadable: keep what is shown
37  }
38}
39
40// The services this worktree's post-start hooks define, registered or not.
41const loadDefined = async ($: EngineInterface) => {
42  try {
43    const ran = await $.process.run([bin, 'hooks'], { timeoutMs: 10000 })
44    const hooks = JSON.parse(ran.stdout) as { name: string; expanded: string }[]
45    await update($, defined, () => parseDefined(hooks))
46  } catch {
47    await update($, defined, () => [])
48  }
49}
50
51// Shows the service's log the way config.jsonc says (a kitty split, a tmux pane, ...); without that, toasts the path.
52const showLog = async ($: EngineInterface, r: Route) => {
53  const ran = await $.process.run([bin, 'logs', r.repo, r.branch, '--service', r.service, '--open'], { timeoutMs: 10000 })
54  const text = (ran.exitCode === 0 ? ran.stdout : ran.stderr).trim()
55  if (text) $.ui.toast(text)
56}
57
58// Runs the one hook that registers and starts a defined service.
59const startDefined = async ($: EngineInterface, d: Defined) => {
60  await $.process.run([bin, 'hook', d.name], { timeoutMs: 20000 })
61  await refresh($)
62  await loadDefined($)
63}
64
65// verb is a wt-caddy subcommand; the pane redraws once the refresh sees the new state.
66const run = async ($: EngineInterface, verb: string, r: Route) => {
67  await $.process.run([bin, verb, r.repo, r.branch, '--service', r.service], { timeoutMs: 20000 })
68  await refresh($)
69}
70
71// Asking for the keyboard is only a request: the surface refuses it while the composer still holds
72// the typed "/servers", so this is called again once the command has run.
73const openFocused = async ($: EngineInterface) => {
74  const opened = await $.ui.open({ id: PANE, title: 'Dev servers', focus: true, closeOnEscape: true })
75  if (!opened.isPlaced) $.ui.toast(`/servers: pane not shown (${opened.reason})`)
76}
77
78export const register: Register = on => {
79  on('session.start', async ($, e, next) => {
80    bin = `${await $.env.get('HOME')}/bin/wt-caddy`
81    await $.command.register({ name: 'servers', description: 'Start, stop and open this worktree\'s dev servers' })
82    $.clock.every(3000, () => refresh($))
83    await refresh($)
84    return next(e)
85  })
86
87  on('command.run', { command: 'servers' }, async $ => {
88    await refresh($)
89    await loadDefined($)
90    await openFocused($)
91    $.clock.after(200, () => openFocused($))
92    return { text: 'Dev servers pane opened. Up/Down move, Enter presses, Esc closes. If keys do not reach it, press ctrl+x then Tab.' }
93  })
94
95  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
96    const { Box, Text, Button } = $.ui.resolve(e)
97    const list = await read($, routes)
98    const idle = notRegistered(await read($, defined), list)
99
100    if (list.length === 0 && idle.length === 0) return <Text dimColor>No dev servers defined for this worktree.</Text>
101
102    return (
103      <Box flexDirection="column">
104        {list.map(r => (
105          <Box key={`svc:${r.service}`} flexDirection="column">
106          <Box key={`row:${r.service}`} flexDirection="row">
107            <Text>
108              {r.up ? '●' : '○'} {(r.service === 'main' ? 'dev' : r.service).padEnd(12)}
109            </Text>
110            <Button
111              key={`toggle:${r.service}`}
112              label={r.up ? 'stop' : 'start'}
113              autoFocus={r === list[0] ? true : undefined}
114              onPress={() => run($, r.up ? 'stop' : 'start', r)}
115            />
116          </Box>
117          <Box key={`logrow:${r.service}`} flexDirection="row">
118            <Text dimColor>{'  '.padEnd(16)}</Text>
119            <Button key={`logs:${r.service}`} label="logs" dimColor onPress={() => showLog($, r)} />
120          </Box>
121          </Box>
122        ))}
123        {idle.map(d => (
124          <Box key={`idle:${d.service}`} flexDirection="row">
125            <Text dimColor>○ {(d.service === 'main' ? 'dev' : d.service).padEnd(12)}</Text>
126            <Button key={`startdef:${d.service}`} label="start" onPress={() => startDefined($, d)} />
127            <Text dimColor> not started</Text>
128          </Box>
129        ))}
130        <Text dimColor>Up/Down move, Enter presses, Esc closes</Text>
131      </Box>
132    )
133  })
134}
135

1export type Route = { repo: string; branch: string; service: string; host: string; path: string; up: boolean };
2
3export const CADDY_PORT = 8080;
4
5// Routes of the worktree the session is in; the session may sit in a subdirectory of it.
6export const routesFor = (routes: readonly Route[], cwd: string): Route[] =>
7  routes
8    .filter((r) => cwd === r.path || cwd.startsWith(`${r.path}/`))
9    .sort((a, b) => Number(b.service === "main") - Number(a.service === "main") || a.service.localeCompare(b.service));
10
11// "● dev  ● storybook  ○ server · http://branch.repo.localhost:8080", or undefined when the worktree has no routes.
12export const statusText = (routes: readonly Route[], cwd: string): string | undefined => {
13  const mine = routesFor(routes, cwd);
14  if (mine.length === 0) return undefined;
15  const dots = mine.map((r) => `${r.up ? "●" : "○"} ${r.service === "main" ? "dev" : r.service}`).join("  ");
16  return `${dots} · http://${mine[0].host}:${CADDY_PORT}`;
17};
18
19export type Defined = { name: string; service: string };
20
21// The services a repo's post-start hooks would register: `wt hook show post-start --expanded --format json`
22// entries that run `wt-caddy add`, the service taken from `--service` (none means the main one).
23export const parseDefined = (hooks: readonly { name: string; expanded: string }[]): Defined[] =>
24  hooks
25    .filter((h) => h.expanded.startsWith("wt-caddy add "))
26    .map((h) => ({ name: h.name, service: /--service (\S+)/.exec(h.expanded)?.[1] ?? "main" }));
27
28// Defined services with no route yet in this worktree.
29export const notRegistered = (defined: readonly Defined[], routes: readonly Route[]): Defined[] =>
30  defined.filter((d) => !routes.some((r) => r.service === d.service));
31

1export type Route = { repo: string; branch: string; service: string; host: string; path: string; up: boolean }
2
3export type Defined = { name: string; service: string }
4
5declare module 'claude-code' {
6  interface PluginState {
7    'wt-caddy-status': { routes: Route[]; defined: Defined[] }
8  }
9}
10