opencode-work-context 0.4.5 → 0.4.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -260,15 +260,26 @@ The package invokes the fixed `notify-send` executable directly without a shell
260
260
  or configurable command. Missing commands, unsupported platforms, unavailable
261
261
  desktop sessions, timeouts, and delivery errors are ignored so they cannot
262
262
  interrupt TUI startup or event processing. If the runtime channel is unavailable,
263
- desktop delivery remains a best-effort fallback. Clicking a notification does
264
- not navigate to its session in this release.
263
+ desktop delivery remains a best-effort fallback.
264
+
265
+ On Linux notification servers that support actions, `Open session` routes the
266
+ originating OpenCode process to the affected native session. If that process
267
+ runs in tmux, its validated `TMUX_PANE` is selected with fixed `tmux` arguments.
268
+ On X11, the loader records the active window with `xprop` and raises it with
269
+ `wmctrl` when those optional tools are available. Each step is independent and
270
+ best-effort: navigation can still succeed if pane or window activation fails.
271
+ Wayland focus restrictions and terminal tabs without a public activation API
272
+ may require the user to foreground the terminal manually. Session and window
273
+ identifiers never appear in notification text or configurable commands.
265
274
 
266
275
  Background includes a linked native session that is not selected and any session
267
276
  owned by an OpenCode instance other than the most recently active live instance.
268
277
  Each instance refreshes its lease independently, so a crashed process expires
269
278
  without holding ownership. If the global channel is unavailable, focus falls
270
279
  back to OpenTUI's renderer events and unknown focus is conservatively treated as
271
- foreground.
280
+ foreground. Attention indicators omit the native session already open in the
281
+ current route; retained background state is acknowledged when that session
282
+ receives focus or keyboard activity.
272
283
 
273
284
  To verify cross-project delivery, install and load the TUI integration in two
274
285
  projects, start work in linked session A, then interact with OpenCode B before A
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "opencode-work-context",
3
3
  "type": "module",
4
- "version": "0.4.5",
4
+ "version": "0.4.7",
5
5
  "description": "Filesystem work-context core and OpenCode adapter",
6
6
  "license": "MIT",
7
7
  "author": {
@@ -0,0 +1,159 @@
1
+ import { spawn as nodeSpawn } from "node:child_process";
2
+
3
+ const WINDOW_ID = /^0x[0-9a-f]+$/i;
4
+ const MAX_OUTPUT = 128;
5
+
6
+ const run = ({ executable, args, spawn, timeoutMs, capture = false, children }) => new Promise((resolve) => {
7
+ let child;
8
+ let output = "";
9
+ let timer;
10
+ let settled = false;
11
+ const finish = (result) => {
12
+ if (settled) return;
13
+ settled = true;
14
+ if (timer) clearTimeout(timer);
15
+ if (child) children?.delete(child);
16
+ resolve(result);
17
+ };
18
+ try {
19
+ child = spawn(executable, args, {
20
+ shell: false,
21
+ stdio: capture ? ["ignore", "pipe", "ignore"] : "ignore",
22
+ windowsHide: true,
23
+ });
24
+ children?.set(child, finish);
25
+ child.stdout?.on("data", (chunk) => {
26
+ const text = String(chunk);
27
+ const remaining = MAX_OUTPUT - output.length;
28
+ output += text.slice(0, Math.max(0, remaining));
29
+ if (text.length > remaining) {
30
+ try { child.kill(); } catch {}
31
+ finish({ ok: false, output: "" });
32
+ }
33
+ });
34
+ child.stdout?.once("error", () => finish({ ok: false, output: "" }));
35
+ child.once("error", () => finish({ ok: false, output: "" }));
36
+ child.once("exit", (code) => finish({ ok: code === 0, output }));
37
+ timer = setTimeout(() => {
38
+ try { child.kill(); } catch {}
39
+ finish({ ok: false, output: "" });
40
+ }, timeoutMs);
41
+ timer.unref?.();
42
+ } catch {
43
+ finish({ ok: false, output: "" });
44
+ }
45
+ });
46
+
47
+ const normalizeWindowId = (value) => {
48
+ const text = String(value ?? "").trim();
49
+ if (WINDOW_ID.test(text)) return text === "0x0" ? null : text;
50
+ if (/^\d+$/.test(text)) {
51
+ try {
52
+ const normalized = `0x${BigInt(text).toString(16)}`;
53
+ return normalized === "0x0" ? null : normalized;
54
+ } catch {}
55
+ }
56
+ return null;
57
+ };
58
+
59
+ export const parseActiveWindowId = (output) => {
60
+ const match = String(output ?? "").match(/0x[0-9a-f]+/i);
61
+ return normalizeWindowId(match?.[0]);
62
+ };
63
+
64
+ export const createAttentionActivator = ({
65
+ api,
66
+ env = process.env,
67
+ platform = process.platform,
68
+ spawn = nodeSpawn,
69
+ timeoutMs = 1000,
70
+ captureThrottleMs = 1000,
71
+ navigationTimeoutMs = 2000,
72
+ now = () => Date.now(),
73
+ } = {}) => {
74
+ const paneId = env.TMUX && /^%\d+$/.test(env.TMUX_PANE || "") ? env.TMUX_PANE : null;
75
+ const canCaptureWindow = platform === "linux" && Boolean(env.DISPLAY);
76
+ let windowId = null;
77
+ let lastCapture = 0;
78
+ let capturePending;
79
+ let disposed = false;
80
+ let focused = false;
81
+ let captureGeneration = 0;
82
+ const children = new Map();
83
+
84
+ const capture = () => {
85
+ if (disposed || !canCaptureWindow) return Promise.resolve(windowId);
86
+ focused = true;
87
+ const timestamp = now();
88
+ if (capturePending) return capturePending;
89
+ if (lastCapture && timestamp - lastCapture < captureThrottleMs) return Promise.resolve(windowId);
90
+ lastCapture = timestamp;
91
+ const generation = captureGeneration;
92
+ capturePending = run({ executable: "xprop", args: ["-root", "_NET_ACTIVE_WINDOW"], spawn, timeoutMs, capture: true, children })
93
+ .then((result) => {
94
+ const captured = result.ok ? parseActiveWindowId(result.output) : null;
95
+ if (!disposed && focused && generation === captureGeneration && captured) windowId = captured;
96
+ return windowId;
97
+ })
98
+ .finally(() => { capturePending = undefined; });
99
+ return capturePending;
100
+ };
101
+
102
+ const blur = () => {
103
+ focused = false;
104
+ captureGeneration += 1;
105
+ };
106
+
107
+ const navigate = async (sessionId) => {
108
+ if (typeof api?.route?.navigate !== "function") return false;
109
+ let navigation;
110
+ try { navigation = Promise.resolve(api.route.navigate("session", { sessionID: sessionId })); } catch { return false; }
111
+ let timer;
112
+ try {
113
+ return await Promise.race([
114
+ navigation.then(() => true, () => false),
115
+ new Promise((resolve) => {
116
+ timer = setTimeout(() => resolve(false), navigationTimeoutMs);
117
+ timer.unref?.();
118
+ }),
119
+ ]);
120
+ } finally {
121
+ if (timer) clearTimeout(timer);
122
+ }
123
+ };
124
+
125
+ const activate = async (sessionId) => {
126
+ if (disposed || typeof sessionId !== "string" || !sessionId || sessionId.length > 256) return false;
127
+ let activated = await navigate(sessionId);
128
+ if (disposed) return activated;
129
+ if (paneId) {
130
+ const selectedWindow = await run({ executable: "tmux", args: ["select-window", "-t", paneId], spawn, timeoutMs, children });
131
+ if (disposed) return activated;
132
+ const selectedPane = await run({ executable: "tmux", args: ["select-pane", "-t", paneId], spawn, timeoutMs, children });
133
+ activated = selectedWindow.ok && selectedPane.ok || activated;
134
+ }
135
+ if (disposed) return activated;
136
+ if (windowId && canCaptureWindow) {
137
+ const raised = await run({ executable: "wmctrl", args: ["-ia", windowId], spawn, timeoutMs, children });
138
+ activated = raised.ok || activated;
139
+ }
140
+ return activated;
141
+ };
142
+
143
+ return {
144
+ available: typeof api?.route?.navigate === "function" || Boolean(paneId) || Boolean(windowId),
145
+ capture,
146
+ blur,
147
+ activate,
148
+ target: () => ({ paneId, windowId }),
149
+ dispose: () => {
150
+ disposed = true;
151
+ blur();
152
+ for (const [child, finish] of children) {
153
+ try { child.kill(); } catch {}
154
+ finish({ ok: false, output: "" });
155
+ }
156
+ children.clear();
157
+ },
158
+ };
159
+ };
@@ -3,6 +3,7 @@ import path from "node:path";
3
3
  import { loadConfig } from "../src/storage.js";
4
4
  import { readWorkContextSnapshot } from "../src/work-context-snapshot.js";
5
5
  import { createGlobalAttentionChannel } from "./global-attention.js";
6
+ import { createAttentionActivator } from "./attention-activation.js";
6
7
  import { createDesktopNotifier } from "./notifier.js";
7
8
  import { createTuiFocusTracker } from "./tui-focus.js";
8
9
  import { readTuiState, updateTuiState } from "./tui-state.js";
@@ -78,7 +79,9 @@ export const globalAttentionToast = (event) => {
78
79
  duration: 5000,
79
80
  };
80
81
  };
81
- export const attentionForSession = (api, sessionId) => api?.workContextAttention?.attentionFor?.(sessionId) || null;
82
+ export const attentionForSession = (api, sessionId) => sessionId === currentSessionId(api)
83
+ ? null
84
+ : api?.workContextAttention?.attentionFor?.(sessionId) || null;
82
85
  export const acknowledgeNavigation = (api, sessionId, observedEventKey) => {
83
86
  if (!sessionId || !observedEventKey) return false;
84
87
  return api?.workContextAttention?.acknowledge?.(sessionId, observedEventKey) === true;
@@ -306,7 +309,9 @@ export const createAttentionTuiController = ({ api, projectRoot, read = readWork
306
309
  const acknowledge = (sessionId, observedEventKey) => engine.acknowledge(sessionId, observedEventKey);
307
310
  const aggregate = (matches) => {
308
311
  const bySession = new Map();
312
+ const current = currentSessionId(api);
309
313
  for (const attention of engine.list()) {
314
+ if (attention.sessionId === current) continue;
310
315
  const records = (snapshot?.workspaces || []).flatMap((workspace) => (workspace.sessions || [])
311
316
  .filter((session) => session.opencode_session_id === attention.sessionId)
312
317
  .map((session) => ({ workspace, session })));
@@ -336,7 +341,10 @@ export const tui = async (api, options = {}) => {
336
341
  if (activeControllers.has(api) || api[ACTIVE_ATTENTION_KEY]) return activeControllers.get(api) || api[ACTIVE_ATTENTION_KEY];
337
342
  const projectRoot = api.state?.path?.worktree || api.state?.path?.directory;
338
343
  if (!projectRoot) return;
344
+ const ownsDesktopNotifier = !options.desktopNotifier;
339
345
  const desktopNotifier = options.desktopNotifier || createDesktopNotifier({ enabled: desktopNotificationsEnabled(projectRoot), ...options.notifierOptions });
346
+ const activator = options.attentionActivator
347
+ || (typeof api.route?.navigate === "function" ? createAttentionActivator({ api, ...options.activatorOptions }) : null);
340
348
  let controller;
341
349
  const globalChannel = options.globalAttentionChannel === false
342
350
  ? null
@@ -351,10 +359,14 @@ export const tui = async (api, options = {}) => {
351
359
  onFocus: () => { void controller?.refresh(); },
352
360
  onActivity: () => {
353
361
  globalChannel?.activity?.();
362
+ void activator?.capture?.();
354
363
  const sessionId = currentSessionId(api);
355
364
  if (sessionId) controller?.acknowledge(sessionId);
356
365
  },
357
- onBlur: () => { globalChannel?.deactivate?.(); },
366
+ onBlur: () => {
367
+ globalChannel?.deactivate?.();
368
+ activator?.blur?.();
369
+ },
358
370
  });
359
371
  controller = createAttentionTuiController({
360
372
  api,
@@ -374,7 +386,8 @@ export const tui = async (api, options = {}) => {
374
386
  workspaceTitle: context.workspaceTitle,
375
387
  stageTitle: context.stageTitle,
376
388
  });
377
- void Promise.resolve(desktopNotifier.notify(context)).catch(() => {});
389
+ const onOpen = activator?.available ? () => activator.activate(change.sessionId) : undefined;
390
+ void Promise.resolve(desktopNotifier.notify(context, { onOpen })).catch(() => {});
378
391
  },
379
392
  now: options.now,
380
393
  });
@@ -392,6 +405,8 @@ export const tui = async (api, options = {}) => {
392
405
  cleaned = true;
393
406
  controller.dispose();
394
407
  focus.dispose?.();
408
+ activator?.dispose?.();
409
+ if (ownsDesktopNotifier) desktopNotifier.dispose?.();
395
410
  globalChannel?.dispose?.();
396
411
  for (const registration of registrations) disposeRegistration(registration);
397
412
  if (activeControllers.get(api) === cleanup) activeControllers.delete(api);
@@ -35,9 +35,10 @@ export const buildNotification = ({ workspaceId, workspaceTitle, stageId, stageT
35
35
  };
36
36
  };
37
37
 
38
- export const notifySendArguments = (notification) => [
38
+ export const notifySendArguments = (notification, actionable = false, expireTimeMs = 0) => [
39
39
  "--app-name=OpenCode Work Context",
40
40
  "--urgency=normal",
41
+ ...(actionable ? ["--action=default=Open session", `--expire-time=${expireTimeMs}`] : []),
41
42
  "--",
42
43
  notification.title,
43
44
  notification.body,
@@ -48,36 +49,73 @@ export const createDesktopNotifier = ({
48
49
  platform = process.platform,
49
50
  spawn = nodeSpawn,
50
51
  timeoutMs = 3000,
51
- } = {}) => ({
52
- async notify(context) {
53
- const notification = buildNotification(context);
54
- if (!enabled || platform !== "linux" || !notification) return false;
55
- return new Promise((resolve) => {
56
- let child;
57
- let timer;
58
- let settled = false;
59
- const finish = (delivered) => {
60
- if (settled) return;
61
- settled = true;
62
- if (timer) clearTimeout(timer);
63
- resolve(delivered);
64
- };
65
- try {
66
- child = spawn("notify-send", notifySendArguments(notification), {
67
- shell: false,
68
- stdio: "ignore",
69
- windowsHide: true,
70
- });
71
- child.once("error", () => finish(false));
72
- child.once("exit", (code) => finish(code === 0));
73
- timer = setTimeout(() => {
52
+ actionTimeoutMs = 5 * 60 * 1000,
53
+ } = {}) => {
54
+ const children = new Map();
55
+ let disposed = false;
56
+ const send = (notification, { onOpen, actionable }) => new Promise((resolve) => {
57
+ let child;
58
+ let output = "";
59
+ let timer;
60
+ let settled = false;
61
+ const finish = (result) => {
62
+ if (settled) return;
63
+ settled = true;
64
+ if (timer) clearTimeout(timer);
65
+ if (child) children.delete(child);
66
+ resolve(result);
67
+ };
68
+ try {
69
+ child = spawn("notify-send", notifySendArguments(notification, actionable, actionTimeoutMs), {
70
+ shell: false,
71
+ stdio: actionable ? ["ignore", "pipe", "ignore"] : "ignore",
72
+ windowsHide: true,
73
+ });
74
+ children.set(child, finish);
75
+ child.stdout?.on("data", (chunk) => {
76
+ const text = String(chunk);
77
+ const remaining = 32 - output.length;
78
+ output += text.slice(0, Math.max(0, remaining));
79
+ if (text.length > remaining) {
74
80
  try { child.kill(); } catch {}
75
- finish(false);
76
- }, timeoutMs);
77
- timer.unref?.();
78
- } catch {
79
- finish(false);
81
+ finish({ delivered: false, retry: false });
82
+ }
83
+ });
84
+ child.stdout?.once("error", () => finish({ delivered: false, retry: false }));
85
+ child.once("error", () => finish({ delivered: false, retry: false }));
86
+ child.once("exit", (code) => {
87
+ if (settled) return;
88
+ if (code === 0 && actionable && output.trim() === "default") {
89
+ try { void Promise.resolve(onOpen()).catch(() => {}); } catch {}
90
+ }
91
+ finish({ delivered: code === 0, retry: actionable && code !== 0 });
92
+ });
93
+ timer = setTimeout(() => {
94
+ try { child.kill(); } catch {}
95
+ finish({ delivered: false, retry: false });
96
+ }, actionable ? actionTimeoutMs + 1000 : timeoutMs);
97
+ timer.unref?.();
98
+ } catch {
99
+ finish({ delivered: false, retry: false });
100
+ }
101
+ });
102
+ const notify = async (context, { onOpen } = {}) => {
103
+ const notification = buildNotification(context);
104
+ if (disposed || !enabled || platform !== "linux" || !notification) return false;
105
+ const actionable = typeof onOpen === "function";
106
+ const result = await send(notification, { onOpen, actionable });
107
+ if (result.retry && !disposed) return (await send(notification, { actionable: false })).delivered;
108
+ return result.delivered;
109
+ };
110
+ return {
111
+ notify,
112
+ dispose: () => {
113
+ disposed = true;
114
+ for (const [child, finish] of children) {
115
+ try { child.kill(); } catch {}
116
+ finish({ delivered: false, retry: false });
80
117
  }
81
- });
82
- },
83
- });
118
+ children.clear();
119
+ },
120
+ };
121
+ };