@misakacloud/openchamber-mux 0.0.0-stage → 0.1.1

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.
@@ -0,0 +1,1221 @@
1
+ // ../mux/src/index.ts
2
+ import { resolve as resolve4 } from "node:path";
3
+ // ../mux-core/src/backend.ts
4
+ import { spawn } from "node:child_process";
5
+ function createCommandRunner() {
6
+ return (executable, args, { cwd, env, signal, timeoutMs } = {}) => new Promise((resolve, reject) => {
7
+ const child = spawn(executable, args, {
8
+ cwd,
9
+ env,
10
+ signal,
11
+ timeout: timeoutMs,
12
+ killSignal: "SIGKILL",
13
+ stdio: ["ignore", "pipe", "pipe"],
14
+ windowsHide: true
15
+ });
16
+ let stdout = "";
17
+ let stderr = "";
18
+ child.stdout.setEncoding("utf8").on("data", (chunk) => {
19
+ stdout += chunk;
20
+ });
21
+ child.stderr.setEncoding("utf8").on("data", (chunk) => {
22
+ stderr += chunk;
23
+ });
24
+ let error;
25
+ child.once("error", (cause) => {
26
+ error = cause;
27
+ });
28
+ child.once("close", (exitCode, exitSignal) => {
29
+ if (error)
30
+ reject(error);
31
+ else
32
+ resolve({ exitCode, stdout, stderr, signal: exitSignal ?? undefined });
33
+ });
34
+ });
35
+ }
36
+ async function detectMuxBackend({
37
+ runner = createCommandRunner(),
38
+ platform = process.platform,
39
+ preferred,
40
+ socketName
41
+ } = {}) {
42
+ const fallback = platform === "win32" ? ["psmux", "tmux"] : ["tmux", "psmux"];
43
+ const kinds = preferred ? [preferred, ...fallback.filter((kind) => kind !== preferred)] : fallback;
44
+ for (const kind of kinds) {
45
+ try {
46
+ if ((await runner(kind, ["-V"], { timeoutMs: 2000 })).exitCode === 0) {
47
+ return { kind, executable: kind, platform, socketName };
48
+ }
49
+ } catch (error) {
50
+ const code = error.code;
51
+ if (code !== "ENOENT" && code !== "EACCES")
52
+ throw error;
53
+ }
54
+ }
55
+ return null;
56
+ }
57
+ function quotePosixShell(value) {
58
+ return `'${value.replaceAll("'", "'\\''")}'`;
59
+ }
60
+ function muxCommandArgs(backend, args) {
61
+ return backend.socketName ? ["-L", backend.socketName, ...args] : [...args];
62
+ }
63
+ function useCmd(backend) {
64
+ return (backend.platform ?? process.platform) === "win32" || backend.kind === "psmux";
65
+ }
66
+ function supportsPosixMuxFeatures(backend) {
67
+ return !useCmd(backend);
68
+ }
69
+ function quoteCmdArg(value) {
70
+ if (/["%\r\n\0]/.test(value))
71
+ throw new Error("Unsupported character in cmd.exe argument");
72
+ return `"${value.replace(/\\+$/, "$&$&")}"`;
73
+ }
74
+ function wrapShellCommand(backend, command, channel, exitFilePrefix) {
75
+ const direct = command.endsWith(";") ? `${command}${useCmd(backend) ? " " : `
76
+ `}` : command;
77
+ const executable = backend.executable ?? backend.kind;
78
+ if (exitFilePrefix && supportsPosixMuxFeatures(backend)) {
79
+ const signal = channel ? `${[executable, ...muxCommandArgs(backend, ["wait-for", "-S", channel])].map(quotePosixShell).join(" ")} 2>/dev/null; ` : "";
80
+ return [
81
+ "sh",
82
+ "-lc",
83
+ `trap ':' INT; sh -lc ${quotePosixShell(command)}; __rc=$?; ` + `__oc_exit=${quotePosixShell(exitFilePrefix)}$$.txt; ` + 'if __oc_tmp=$(mktemp "${__oc_exit}.XXXXXX"); then ' + `if ! { printf '%s\\n' "$__rc" > "$__oc_tmp" && mv -f "$__oc_tmp" "$__oc_exit"; }; then rm -f "$__oc_tmp"; fi; fi; ` + signal + 'if [ -n "$SHELL" ] && [ -x "$SHELL" ]; then exec "$SHELL" -i; ' + "elif [ -x /bin/bash ]; then exec /bin/bash -i; else exec /bin/sh -i; fi"
84
+ ];
85
+ }
86
+ if (!channel)
87
+ return useCmd(backend) ? ["cmd.exe", "/d", "/c", direct] : ["sh", "-lc", direct];
88
+ const args = muxCommandArgs(backend, ["wait-for", "-S", channel]);
89
+ if (useCmd(backend)) {
90
+ if (/["%!^\r\n]/.test(command) || [executable, ...args].some((arg) => /["%!\r\n\0]/.test(arg))) {
91
+ return ["cmd.exe", "/d", "/c", direct];
92
+ }
93
+ const signal = [executable, ...args].map(quoteCmdArg).join(" ");
94
+ return [
95
+ "cmd.exe",
96
+ "/d",
97
+ "/v:on",
98
+ "/c",
99
+ `cmd.exe /d /v:off /s /c "${command}" & set "__oc_rc=!errorlevel!" & ${signal} & exit /b !__oc_rc!`
100
+ ];
101
+ }
102
+ const signal = [executable, ...args].map(quotePosixShell).join(" ");
103
+ return ["sh", "-lc", `sh -lc ${quotePosixShell(command)}; __rc=$?; ${signal}; exit "$__rc"`];
104
+ }
105
+ function buildAttachCommand(backend, sessionName) {
106
+ const executable = backend.executable ?? backend.kind;
107
+ const args = muxCommandArgs(backend, ["attach-session", "-t", `=${sessionName}`]);
108
+ if (useCmd(backend)) {
109
+ return `cmd.exe /d /v:off /s /c "${[executable, ...args].map(quoteCmdArg).join(" ")}"`;
110
+ }
111
+ return [executable, ...args].map(quotePosixShell).join(" ");
112
+ }
113
+ function stripAnsi(text) {
114
+ return text.replace(/(?:\x1b\]|\x9d)[^\x07\x1b\x9c]*(?:\x07|\x1b\\|\x9c)/g, "").replace(/(?:\x1b[P^_X]|[\x90\x98\x9e\x9f])[^\x1b\x9c]*(?:\x1b\\|\x9c)/g, "").replace(/(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]|\x1b[ -/]*[@-_]/g, "");
115
+ }
116
+ // ../mux-core/src/tmux.ts
117
+ import { mkdtemp, rm, writeFile } from "node:fs/promises";
118
+ import { tmpdir } from "node:os";
119
+ import { join } from "node:path";
120
+ var OPTIONS = {
121
+ managed: "@opencode_mux_managed",
122
+ id: "@opencode_mux_id",
123
+ role: "@opencode_mux_role",
124
+ name: "@opencode_mux_name",
125
+ session: "@opencode_mux_session",
126
+ dir: "@opencode_mux_dir",
127
+ cmd: "@opencode_mux_cmd"
128
+ };
129
+ var cleanupHookName = "pane-died[100]";
130
+ var cleanupHook = 'if-shell -F "#{pane_dead}" "kill-pane"';
131
+ var byobuTable = "mux-byobu";
132
+ var themeHook = "after-new-window[100]";
133
+ var mouseKey = /^(?:[CMS]-)*(?:Mouse|Wheel|DoubleClick|TripleClick)\S*$/;
134
+ var keyBinding = /^(bind-key\s+(?:-r\s+)?-T\s+)(\S+)(\s+(\S+)\s+\S.*)$/;
135
+ function mouseBindings(stdout, table) {
136
+ return stdout.split(/\r?\n/).flatMap((line) => {
137
+ const match = keyBinding.exec(line);
138
+ return match && match[2] === table && mouseKey.test(match[4]) ? [`${match[1]}${byobuTable}${match[3]}`] : [];
139
+ });
140
+ }
141
+ var fallbackMouseBindings = [
142
+ ["MouseDown1Status", "switch-client -t ="],
143
+ ["WheelUpStatus", "previous-window"],
144
+ ["WheelDownStatus", "next-window"],
145
+ ["MouseDown1Pane", "select-pane -t = ; send-keys -M"],
146
+ ["WheelUpPane", 'if-shell -F "#{||:#{alternate_on},#{pane_in_mode},#{mouse_any_flag}}" { send-keys -M } { copy-mode -e }'],
147
+ ["WheelDownPane", 'if-shell -F "#{||:#{pane_in_mode},#{mouse_any_flag}}" "send-keys -M"'],
148
+ ["MouseDrag1Pane", 'if-shell -F "#{||:#{pane_in_mode},#{mouse_any_flag}}" { send-keys -M } { copy-mode -M }'],
149
+ ["MouseDrag1Border", "resize-pane -M"]
150
+ ];
151
+ function sessionThemeOptions(ascii) {
152
+ return [
153
+ ["status", "on"],
154
+ ["status-position", "bottom"],
155
+ ["status-interval", "1"],
156
+ ["status-justify", "left"],
157
+ ["status-style", "bg=#333333,fg=#eeeeee"],
158
+ ["status-left-style", "default"],
159
+ ["status-left-length", "16"],
160
+ ["status-left", ascii ? "#[bg=#5faf5f,fg=#1c1c1c,bold] mux #[default] " : "#[bg=#5faf5f,fg=#1c1c1c,bold] mux #[bg=#333333,fg=#5faf5f,nobold]#[default] "],
161
+ ["status-right-style", "default"],
162
+ ["status-right-length", "96"],
163
+ ["status-right", ascii ? "#S + %Y-%m-%d + %H:%M:%S" : "#[bg=#333333,fg=#4e4e4e]#[bg=#4e4e4e,fg=#eeeeee] #S #[bg=#4e4e4e,fg=#1c1c1c]#[bg=#1c1c1c,fg=#b8b8b8] %Y-%m-%d #[fg=#eeeeee,bold]%H:%M:%S #[default]"],
164
+ ["mouse", "on"],
165
+ ["renumber-windows", "on"],
166
+ ["visual-activity", "off"],
167
+ ["message-style", "bg=#75507b,fg=#eeeeee,bold"],
168
+ ["message-command-style", "bg=#333333,fg=#87d75f,bold"]
169
+ ];
170
+ }
171
+ function windowThemeOptions(ascii) {
172
+ const compact = " #I:#W#{?window_flags,#{window_flags},} ";
173
+ return [
174
+ ["window-status-style", "bg=#333333,fg=#b8b8b8"],
175
+ ["window-status-current-style", "bg=#eeeeee,fg=#1c1c1c,bold"],
176
+ ["window-status-activity-style", "bg=#333333,fg=#87d75f,bold"],
177
+ ["window-status-bell-style", "bg=#dd4814,fg=#eeeeee,bold"],
178
+ ["window-status-separator", " "],
179
+ ["window-status-format", ascii ? compact : " #I #W#{?window_flags,#{window_flags},} "],
180
+ ["window-status-current-format", ascii ? compact : "#[bg=#eeeeee,fg=#333333,nobold]#[fg=#1c1c1c,bold] #I #W#{?window_flags,#{window_flags},} #[bg=#333333,fg=#eeeeee,nobold]"],
181
+ ["pane-border-style", "fg=#4e4e4e"],
182
+ ["pane-active-border-style", "fg=#5faf5f"],
183
+ ["mode-style", "bg=#75507b,fg=#eeeeee"],
184
+ ["monitor-activity", "on"]
185
+ ];
186
+ }
187
+ var commandList = (commands) => commands.flatMap((command, index) => index ? [";", ...command] : command);
188
+ var separator = "\x1F";
189
+ var paneFormat = [
190
+ "session_name",
191
+ "window_index",
192
+ "window_name",
193
+ "pane_id",
194
+ "pane_pid",
195
+ "pane_current_path",
196
+ "pane_current_command",
197
+ "pane_dead",
198
+ "pane_dead_status",
199
+ "pane_dead_signal",
200
+ ...Object.values(OPTIONS),
201
+ "pane_title"
202
+ ].map((field) => `#{${field}}`).join(separator);
203
+ function numberField(value) {
204
+ return /^-?\d+$/.test(value) ? Number(value) : undefined;
205
+ }
206
+ var encodedPrefix = "opencode-b64:";
207
+ function encodeField(value) {
208
+ return /[\r\n\x1f]|;$/.test(value) || value.startsWith(encodedPrefix) ? encodedPrefix + Buffer.from(value).toString("base64") : value;
209
+ }
210
+ function decodeField(value) {
211
+ return value.startsWith(encodedPrefix) ? Buffer.from(value.slice(encodedPrefix.length), "base64").toString() : value || undefined;
212
+ }
213
+ function parsePanes(stdout) {
214
+ return stdout.split(/\r?\n/).flatMap((line) => {
215
+ const fields = line.split(separator);
216
+ if (fields.length < 18 || !/^%\d+$/.test(fields[3]))
217
+ return [];
218
+ const [
219
+ sessionName,
220
+ index,
221
+ windowName,
222
+ paneId,
223
+ pid,
224
+ paneCurrentPath,
225
+ paneCurrentCommand,
226
+ dead,
227
+ status,
228
+ signal,
229
+ managed,
230
+ taskId,
231
+ role,
232
+ name,
233
+ sessionId,
234
+ cwd,
235
+ command,
236
+ ...title
237
+ ] = fields;
238
+ const signum = numberField(signal);
239
+ return [{
240
+ sessionName,
241
+ windowIndex: Number(index),
242
+ windowName,
243
+ paneId,
244
+ panePid: numberField(pid),
245
+ paneCurrentPath,
246
+ paneCurrentCommand,
247
+ paneDead: dead === "1",
248
+ exitCode: dead === "1" ? numberField(status) ?? (signum ? 128 + signum : undefined) : undefined,
249
+ paneTitle: title.join(separator),
250
+ managed: managed === "1",
251
+ taskId: decodeField(taskId),
252
+ role: role === "build" || role === "service" ? role : undefined,
253
+ taskName: decodeField(name),
254
+ sessionId: decodeField(sessionId),
255
+ cwd: decodeField(cwd),
256
+ command: decodeField(command)
257
+ }];
258
+ });
259
+ }
260
+ function noServer(result) {
261
+ return result.exitCode === 1 && /no server running|no sessions|error connecting to .+ \(No such file or directory\)/i.test(result.stderr);
262
+ }
263
+
264
+ class MuxCommandError extends Error {
265
+ subcommand;
266
+ result;
267
+ constructor(subcommand, result) {
268
+ super(`${subcommand} failed (${result.exitCode ?? result.signal ?? "no exit code"}): ${result.stderr.trim()}`);
269
+ this.subcommand = subcommand;
270
+ this.result = result;
271
+ this.name = "MuxCommandError";
272
+ }
273
+ }
274
+ function createMuxClient(backend, runner, options = {}) {
275
+ const run = (args, options) => runner(backend.executable ?? backend.kind, muxCommandArgs(backend, args), options);
276
+ const checked = async (args, options) => {
277
+ const result = await run(args, options);
278
+ if (result.exitCode !== 0)
279
+ throw new MuxCommandError(args[0], result);
280
+ return result;
281
+ };
282
+ async function listPanes() {
283
+ const result = await run(["list-panes", "-a", "-F", paneFormat]);
284
+ if (noServer(result))
285
+ return [];
286
+ if (result.exitCode !== 0)
287
+ throw new MuxCommandError("list-panes", result);
288
+ return parsePanes(result.stdout);
289
+ }
290
+ async function setMetadata(paneId, task) {
291
+ const entries = [
292
+ [OPTIONS.id, task.id],
293
+ [OPTIONS.role, task.role],
294
+ [OPTIONS.name, task.name],
295
+ [OPTIONS.session, task.sessionId ?? ""],
296
+ [OPTIONS.dir, task.cwd],
297
+ [OPTIONS.cmd, task.command],
298
+ [OPTIONS.managed, "1"]
299
+ ];
300
+ const commands = entries.map(([key, value]) => ["set-option", "-p", "-t", paneId, key, encodeField(value)]);
301
+ if (backend.kind === "psmux") {
302
+ for (const command of commands)
303
+ await checked(command);
304
+ } else {
305
+ await checked(commands.flatMap((command, index) => index ? [";", ...command] : command));
306
+ }
307
+ }
308
+ async function respawnPane(paneId, { cwd, command, channel, metadata }, taskId = metadata?.id) {
309
+ const exitFilePrefix = taskId && await options.prepareExitFile?.(paneId, taskId);
310
+ if (supportsPosixMuxFeatures(backend)) {
311
+ if (exitFilePrefix)
312
+ await checked(["set-hook", "-p", "-t", paneId, cleanupHookName, cleanupHook]);
313
+ else if (metadata)
314
+ await checked(["set-hook", "-p", "-u", "-t", paneId, cleanupHookName]);
315
+ }
316
+ await checked(["respawn-pane", "-k", "-t", paneId, "-c", cwd, ...wrapShellCommand(backend, command, channel, exitFilePrefix)]);
317
+ if (metadata)
318
+ await setMetadata(paneId, metadata);
319
+ }
320
+ async function transplantMouseBindings() {
321
+ const existing = await run(["list-keys", "-T", byobuTable]);
322
+ if (existing.exitCode === 0 && mouseBindings(existing.stdout, byobuTable).length)
323
+ return;
324
+ const root = await run(["list-keys", "-T", "root"]);
325
+ const bindings = root.exitCode === 0 ? mouseBindings(root.stdout, "root") : [];
326
+ if (bindings.length) {
327
+ const dir = await mkdtemp(join(tmpdir(), "opencode-mux-keys-"));
328
+ try {
329
+ const path = join(dir, "mouse.conf");
330
+ await writeFile(path, `${bindings.join(`
331
+ `)}
332
+ `, { mode: 384 });
333
+ if ((await run(["source-file", path])).exitCode === 0)
334
+ return;
335
+ } finally {
336
+ await rm(dir, { recursive: true, force: true });
337
+ }
338
+ }
339
+ await checked(commandList(fallbackMouseBindings.map(([key, command]) => ["bind-key", "-T", byobuTable, key, command])));
340
+ }
341
+ async function enableByobuKeys(session) {
342
+ const bindings = [
343
+ ["F2", "new-window", "-c", "#{pane_current_path}"],
344
+ ["F3", "previous-window"],
345
+ ["F4", "next-window"],
346
+ ["F6", "detach-client"],
347
+ ["F7", "copy-mode"],
348
+ ["F8", "command-prompt", "-I", "#W", "-p", "rename-window ", 'rename-window "%%"'],
349
+ ["M-Left", "previous-window"],
350
+ ["M-Right", "next-window"]
351
+ ];
352
+ await transplantMouseBindings();
353
+ await checked(commandList([
354
+ ...bindings.map((binding) => ["bind-key", "-T", byobuTable, ...binding]),
355
+ ["set-option", "-t", session, "key-table", byobuTable]
356
+ ]));
357
+ }
358
+ async function applySessionTheme(sessionName, paneId, variant) {
359
+ if (variant === "off")
360
+ return;
361
+ const ascii = variant === "ascii" || !supportsPosixMuxFeatures(backend);
362
+ const windowOptions = windowThemeOptions(ascii);
363
+ const hook = windowOptions.map(([key, value]) => `set-option -w ${key} ${JSON.stringify(value)}`).join("; ");
364
+ const commands = [
365
+ ...sessionThemeOptions(ascii).map(([key, value]) => ["set-option", "-t", sessionName, key, value]),
366
+ ["set-hook", "-t", sessionName, themeHook, hook],
367
+ ...windowOptions.map(([key, value]) => ["set-option", "-w", "-t", paneId, key, value])
368
+ ];
369
+ if (backend.kind === "psmux") {
370
+ for (const command of commands) {
371
+ const result = await run(command);
372
+ if (result.exitCode !== 0 && !/unknown|unsupported|not (?:yet )?(?:supported|implemented)|invalid (?:option|style|hook|index|value)/i.test(result.stderr)) {
373
+ throw new MuxCommandError(command[0], result);
374
+ }
375
+ }
376
+ } else {
377
+ await checked(commandList(commands));
378
+ }
379
+ }
380
+ async function killPane(paneId) {
381
+ const result = await run(["kill-pane", "-t", paneId]);
382
+ if (result.exitCode !== 0 && !noServer(result) && !/can't find pane|no such pane|pane not found/i.test(result.stderr)) {
383
+ throw new MuxCommandError("kill-pane", result);
384
+ }
385
+ }
386
+ async function killSession(sessionName) {
387
+ const result = await run(["kill-session", "-t", `=${sessionName}`]);
388
+ if (result.exitCode !== 0 && !noServer(result) && !/can't find session|no such session|session not found/i.test(result.stderr)) {
389
+ throw new MuxCommandError("kill-session", result);
390
+ }
391
+ }
392
+ async function createManagedPane(task) {
393
+ const placeholder = wrapShellCommand(backend, backend.kind === "psmux" || (backend.platform ?? process.platform) === "win32" ? "ping -t 127.0.0.1 >nul" : "exec sleep 86400");
394
+ const common = ["-c", task.cwd, "-P", "-F", "#{pane_id}", ...placeholder];
395
+ const first = await run(["new-session", "-d", "-s", task.muxSession, ...common]);
396
+ let result = first;
397
+ if (first.exitCode !== 0) {
398
+ if (!/duplicate session|session already exists/i.test(first.stderr))
399
+ throw new MuxCommandError("new-session", first);
400
+ result = await checked(["new-window", "-d", "-t", `${task.muxSession}:`, ...common]);
401
+ }
402
+ const paneId = result.stdout.trim();
403
+ if (!/^%\d+$/.test(paneId))
404
+ throw new Error(`Invalid pane id from mux: ${paneId}`);
405
+ try {
406
+ const remain = ["set-option", "-p", "-t", paneId, "remain-on-exit", "on"];
407
+ if (backend.kind === "tmux") {
408
+ remain.push(";", "set-option", "-p", "-t", paneId, "remain-on-exit-format", "");
409
+ }
410
+ await checked(remain);
411
+ await setMetadata(paneId, task);
412
+ await applySessionTheme(task.muxSession, paneId, options.statusTheme ?? "powerline");
413
+ if (options.byobuKeys && supportsPosixMuxFeatures(backend))
414
+ await enableByobuKeys(task.muxSession);
415
+ await respawnPane(paneId, task, task.id);
416
+ } catch (error) {
417
+ await killPane(paneId).catch(() => {});
418
+ throw error;
419
+ }
420
+ return paneId;
421
+ }
422
+ async function sendInterrupt(paneId) {
423
+ await checked(["send-keys", "-t", paneId, "C-c"]);
424
+ }
425
+ async function sendKeys(paneId, text, enter = false) {
426
+ if (text)
427
+ await checked(["send-keys", "-t", paneId, "-l", "--", text.endsWith(";") ? text.slice(0, -1) + "\\;" : text]);
428
+ if (enter)
429
+ await checked(["send-keys", "-t", paneId, "Enter"]);
430
+ }
431
+ async function capturePane(paneId, lines) {
432
+ if (lines !== undefined && (!Number.isSafeInteger(lines) || lines < 0)) {
433
+ throw new RangeError("lines must be a non-negative integer");
434
+ }
435
+ if (lines === 0)
436
+ return "";
437
+ const args = ["capture-pane", "-p", "-t", paneId];
438
+ if (lines !== undefined)
439
+ args.push("-S", `-${lines}`);
440
+ const result = await checked(args);
441
+ const output = stripAnsi(result.stdout).replaceAll(`\r
442
+ `, `
443
+ `).replace(/(?:\n[ \t]*)+$/, "");
444
+ return lines === undefined ? output : output.split(`
445
+ `).slice(-lines).join(`
446
+ `);
447
+ }
448
+ async function waitForChannel(channel, { timeoutMs, signal } = {}) {
449
+ if (signal?.aborted || timeoutMs !== undefined && timeoutMs <= 0)
450
+ return false;
451
+ const controller = new AbortController;
452
+ const abort = () => controller.abort();
453
+ signal?.addEventListener("abort", abort, { once: true });
454
+ const timer = timeoutMs === undefined ? undefined : setTimeout(abort, timeoutMs);
455
+ try {
456
+ return (await run(["wait-for", channel], { signal: controller.signal, timeoutMs })).exitCode === 0;
457
+ } catch (error) {
458
+ if (controller.signal.aborted)
459
+ return false;
460
+ throw error;
461
+ } finally {
462
+ signal?.removeEventListener("abort", abort);
463
+ clearTimeout(timer);
464
+ }
465
+ }
466
+ return { listPanes, createManagedPane, respawnPane, sendInterrupt, sendKeys, capturePane, killPane, killSession, waitForChannel };
467
+ }
468
+ // ../mux-core/src/state.ts
469
+ import { randomUUID } from "node:crypto";
470
+ import { mkdir, readdir, readFile, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
471
+ import { homedir } from "node:os";
472
+ import { basename, join as join2, resolve } from "node:path";
473
+ function resolveMuxStateDir(env = process.env, home = homedir()) {
474
+ return env.OPENCODE_MUX_STATE_DIR || (env.XDG_STATE_HOME ? join2(env.XDG_STATE_HOME, "opencode-mux") : join2(home, ".local", "state", "opencode-mux"));
475
+ }
476
+ function isMissing(error) {
477
+ return error.code === "ENOENT";
478
+ }
479
+ function isSafeTaskId(id) {
480
+ return /^[a-zA-Z0-9_-]{1,128}$/.test(id) && !/^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i.test(id);
481
+ }
482
+ function checkTask(value, id) {
483
+ if (!value || typeof value !== "object")
484
+ return false;
485
+ const task = value;
486
+ return task.id === id && (task.role === "build" || task.role === "service") && (task.muxKind === "tmux" || task.muxKind === "psmux") && ["running", "succeeded", "failed", "stopped", "gone"].includes(task.status ?? "") && typeof task.name === "string" && typeof task.cwd === "string" && typeof task.command === "string" && typeof task.muxSession === "string" && /^%\d+$/.test(task.paneId ?? "") && Number.isSafeInteger(task.restartCount) && typeof task.createdAt === "string" && typeof task.updatedAt === "string";
487
+ }
488
+ function createMuxState(stateDir = resolveMuxStateDir()) {
489
+ const dir = join2(stateDir, "tasks");
490
+ const exitDir = resolve(stateDir, "exit");
491
+ const pathFor = (id) => {
492
+ if (!isSafeTaskId(id))
493
+ throw new Error(`Invalid mux task id: ${id}`);
494
+ return join2(dir, `${id}.json`);
495
+ };
496
+ function exitFilePrefix(paneId, id) {
497
+ if (!/^%\d+$/.test(paneId))
498
+ throw new Error(`Invalid mux pane id: ${paneId}`);
499
+ if (!isSafeTaskId(id))
500
+ throw new Error(`Invalid mux task id: ${id}`);
501
+ return join2(exitDir, `p${paneId.slice(1)}_${id}_`);
502
+ }
503
+ async function prepareExitFile(paneId, id) {
504
+ const prefix = exitFilePrefix(paneId, id);
505
+ await mkdir(exitDir, { recursive: true, mode: 448 });
506
+ return prefix;
507
+ }
508
+ async function findExitFiles(paneId, id) {
509
+ const prefix = basename(exitFilePrefix(paneId, id));
510
+ try {
511
+ return (await readdir(exitDir)).filter((name) => name.startsWith(prefix) && /^\d+\.txt$/.test(name.slice(prefix.length))).map((name) => join2(exitDir, name));
512
+ } catch (error) {
513
+ if (isMissing(error))
514
+ return [];
515
+ throw error;
516
+ }
517
+ }
518
+ async function readExitCode({ paneId, id, panePid }) {
519
+ const files = panePid === undefined ? await findExitFiles(paneId, id) : [`${exitFilePrefix(paneId, id)}${panePid}.txt`];
520
+ if (files.length !== 1)
521
+ return;
522
+ try {
523
+ const content = await readFile(files[0], "utf8");
524
+ const code = Number(content);
525
+ return /^\d+\n$/.test(content) && Number.isSafeInteger(code) ? code : undefined;
526
+ } catch (error) {
527
+ if (isMissing(error))
528
+ return;
529
+ throw error;
530
+ }
531
+ }
532
+ async function deleteExitFile({ paneId, id, panePid }) {
533
+ const files = panePid === undefined ? await findExitFiles(paneId, id) : [`${exitFilePrefix(paneId, id)}${panePid}.txt`];
534
+ await Promise.all(files.map((file) => rm2(file, { force: true })));
535
+ }
536
+ async function readTask(id) {
537
+ try {
538
+ const value = JSON.parse(await readFile(pathFor(id), "utf8"));
539
+ return checkTask(value, id) ? value : undefined;
540
+ } catch (error) {
541
+ if (isMissing(error) || error instanceof SyntaxError)
542
+ return;
543
+ throw error;
544
+ }
545
+ }
546
+ async function writeTask(task) {
547
+ const dest = pathFor(task.id);
548
+ const temp = join2(dir, `.${randomUUID()}.tmp`);
549
+ await mkdir(dir, { recursive: true, mode: 448 });
550
+ try {
551
+ await writeFile2(temp, `${JSON.stringify(task, null, 2)}
552
+ `, { flag: "wx", mode: 384 });
553
+ await rename(temp, dest);
554
+ } finally {
555
+ await rm2(temp, { force: true });
556
+ }
557
+ }
558
+ async function deleteTask(id) {
559
+ await rm2(pathFor(id), { force: true });
560
+ }
561
+ async function listTasks() {
562
+ try {
563
+ const entries = await readdir(dir, { withFileTypes: true });
564
+ const ids = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -5)).filter(isSafeTaskId).sort();
565
+ return (await Promise.all(ids.map(readTask))).filter((task) => task !== undefined);
566
+ } catch (error) {
567
+ if (isMissing(error))
568
+ return [];
569
+ throw error;
570
+ }
571
+ }
572
+ return { stateDir, readTask, writeTask, deleteTask, listTasks, prepareExitFile, readExitCode, deleteExitFile };
573
+ }
574
+ // ../mux-core/src/manager.ts
575
+ import { createHash, randomUUID as randomUUID2 } from "node:crypto";
576
+ import { basename as basename2, resolve as resolve2 } from "node:path";
577
+ var now = () => new Date().toISOString();
578
+ function projectMuxSession(cwd) {
579
+ const directory = resolve2(cwd);
580
+ const slug = basename2(directory).toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40).replace(/^-+|-+$/g, "") || "project";
581
+ const hash = createHash("sha256").update(directory).digest("hex").slice(0, 8);
582
+ return `oc-${slug}-${hash}`;
583
+ }
584
+ function duration(value, name, min = 0) {
585
+ if (!Number.isSafeInteger(value) || value < min || value > 2147483647) {
586
+ throw new RangeError(`${name} must be an integer from ${min} to 2147483647`);
587
+ }
588
+ return value;
589
+ }
590
+ function validateCommand(command) {
591
+ if (!command.trim() || command.includes("\x00"))
592
+ throw new Error("A non-empty mux command is required");
593
+ }
594
+ function statusFromPane(pane, exitCode, stopRequested = false) {
595
+ if (exitCode !== undefined)
596
+ return exitCode === 0 ? "succeeded" : exitCode >= 128 ? "stopped" : "failed";
597
+ if (!pane.paneDead)
598
+ return "running";
599
+ if (stopRequested && (pane.exitCode === undefined || [0, 130, 143].includes(pane.exitCode)))
600
+ return "stopped";
601
+ return pane.exitCode === 0 ? "succeeded" : "failed";
602
+ }
603
+ function matches(task, filter) {
604
+ return (filter.cwd === undefined || task.cwd === resolve2(filter.cwd)) && (filter.role === undefined || task.role === filter.role) && (filter.name === undefined || task.name === filter.name) && (filter.status === undefined || task.status === filter.status) && (filter.sessionId === undefined || task.sessionId === filter.sessionId);
605
+ }
606
+ var delay = (ms) => new Promise((done) => {
607
+ setTimeout(done, ms);
608
+ });
609
+ function createMuxManager(options = {}) {
610
+ const runner = options.runner ?? createCommandRunner();
611
+ const state = createMuxState(options.stateDir);
612
+ const polling = duration(options.pollIntervalMs ?? 100, "pollIntervalMs", 1);
613
+ let backendPromise;
614
+ function getBackend() {
615
+ if (options.backend)
616
+ return Promise.resolve({
617
+ ...options.backend,
618
+ platform: options.platform ?? options.backend.platform,
619
+ socketName: options.socketName ?? options.backend.socketName
620
+ });
621
+ return backendPromise ??= detectMuxBackend({ ...options, runner }).then((backend) => {
622
+ if (!backend)
623
+ throw new Error("No tmux or psmux executable found");
624
+ return backend;
625
+ }).catch((error) => {
626
+ backendPromise = undefined;
627
+ throw error;
628
+ });
629
+ }
630
+ const client = async () => {
631
+ const backend = await getBackend();
632
+ return createMuxClient(backend, runner, {
633
+ byobuKeys: options.byobuKeys ?? true,
634
+ statusTheme: options.statusTheme,
635
+ prepareExitFile: options.keepShellOnExit !== false && supportsPosixMuxFeatures(backend) ? state.prepareExitFile : undefined
636
+ });
637
+ };
638
+ function readExitCode(backend, pane, id, panePid = pane.panePid) {
639
+ return supportsPosixMuxFeatures(backend) ? state.readExitCode({ paneId: pane.paneId, id, panePid }) : undefined;
640
+ }
641
+ function paneResult(pane, exitCode, stopRequested) {
642
+ return {
643
+ status: statusFromPane(pane, exitCode, stopRequested),
644
+ exitCode: exitCode ?? pane.exitCode,
645
+ shell: !pane.paneDead && exitCode !== undefined ? true : undefined
646
+ };
647
+ }
648
+ let queue = Promise.resolve();
649
+ function serial(work) {
650
+ const result = queue.then(work);
651
+ queue = result.catch(() => {});
652
+ return result;
653
+ }
654
+ async function reconcile() {
655
+ const backend = await getBackend();
656
+ const [stored, panes] = await Promise.all([state.listTasks(), (await client()).listPanes()]);
657
+ const byId = new Map(stored.map((task) => [task.id, task]));
658
+ const liveById = new Map;
659
+ for (const pane of panes) {
660
+ if (!pane.managed || !pane.taskId || !isSafeTaskId(pane.taskId) || !pane.role)
661
+ continue;
662
+ const current = liveById.get(pane.taskId) ?? [];
663
+ if (!current.some(({ paneId }) => paneId === pane.paneId))
664
+ current.push(pane);
665
+ liveById.set(pane.taskId, current);
666
+ }
667
+ const tasks = [];
668
+ for (const storedTask of stored) {
669
+ if (storedTask.muxKind !== backend.kind || storedTask.socketName !== backend.socketName)
670
+ continue;
671
+ const candidates = liveById.get(storedTask.id) ?? [];
672
+ const pane = candidates.find(({ paneId }) => paneId === storedTask.paneId) ?? (candidates.length === 1 ? candidates[0] : undefined);
673
+ const panePid = pane?.panePid ?? (pane?.paneDead && pane.paneId === storedTask.paneId ? storedTask.panePid : undefined);
674
+ const exitCode = pane && await readExitCode(backend, pane, storedTask.id, panePid);
675
+ const restarted = !!pane && (pane.paneId !== storedTask.paneId || pane.panePid !== undefined && storedTask.panePid !== undefined && pane.panePid !== storedTask.panePid || !pane.paneDead && exitCode === undefined && storedTask.status !== "running");
676
+ if (restarted && (pane.paneId !== storedTask.paneId || storedTask.panePid !== undefined && panePid !== storedTask.panePid)) {
677
+ await state.deleteExitFile(storedTask);
678
+ }
679
+ const stopRequested = restarted ? undefined : storedTask.stopRequested;
680
+ const task = pane ? {
681
+ ...storedTask,
682
+ muxSession: pane.sessionName,
683
+ paneId: pane.paneId,
684
+ panePid,
685
+ ...paneResult(pane, exitCode, stopRequested),
686
+ stopRequested,
687
+ forceStopped: undefined,
688
+ restartCount: storedTask.restartCount + Number(restarted)
689
+ } : {
690
+ ...storedTask,
691
+ status: storedTask.forceStopped ? "stopped" : "gone",
692
+ shell: undefined
693
+ };
694
+ if (JSON.stringify(task) !== JSON.stringify(storedTask)) {
695
+ task.updatedAt = now();
696
+ await state.writeTask(task);
697
+ }
698
+ tasks.push(task);
699
+ }
700
+ for (const [id, candidates] of liveById) {
701
+ if (byId.has(id) || candidates.length !== 1)
702
+ continue;
703
+ const pane = candidates[0];
704
+ const timestamp = now();
705
+ const task = {
706
+ id,
707
+ role: pane.role,
708
+ name: pane.taskName ?? pane.windowName,
709
+ cwd: pane.cwd ?? pane.paneCurrentPath,
710
+ command: pane.command ?? pane.paneCurrentCommand,
711
+ sessionId: pane.sessionId,
712
+ muxKind: backend.kind,
713
+ muxSession: pane.sessionName,
714
+ socketName: backend.socketName,
715
+ paneId: pane.paneId,
716
+ panePid: pane.panePid,
717
+ ...paneResult(pane, await readExitCode(backend, pane, id)),
718
+ restartCount: 0,
719
+ createdAt: timestamp,
720
+ updatedAt: timestamp
721
+ };
722
+ await state.writeTask(task);
723
+ tasks.push(task);
724
+ }
725
+ return tasks;
726
+ }
727
+ async function find(id) {
728
+ return (await reconcile()).find((task) => task.id === id);
729
+ }
730
+ async function findNamed(role, { name, cwd }) {
731
+ return (await reconcile()).filter((t) => t.role === role && t.name === name && t.cwd === cwd).sort((a, b) => Number(a.status === "gone") - Number(b.status === "gone") || b.updatedAt.localeCompare(a.updatedAt))[0];
732
+ }
733
+ async function start(role, identity, command, existing, channel) {
734
+ validateCommand(command);
735
+ if (!identity.name.trim() || identity.name.includes("\x00"))
736
+ throw new Error("A non-empty mux task name is required");
737
+ const backend = await getBackend();
738
+ const mux = await client();
739
+ const meta = {
740
+ ...identity,
741
+ id: existing?.id ?? randomUUID2(),
742
+ role,
743
+ command,
744
+ muxSession: existing?.muxSession ?? projectMuxSession(identity.cwd),
745
+ sessionId: identity.sessionId ?? existing?.sessionId,
746
+ channel
747
+ };
748
+ const paneAvailable = existing && existing.status !== "gone" && (await mux.listPanes()).some((pane) => pane.paneId === existing.paneId && pane.managed && pane.taskId === existing.id);
749
+ if (existing)
750
+ await state.deleteExitFile(existing);
751
+ let paneId;
752
+ if (paneAvailable) {
753
+ paneId = existing.paneId;
754
+ await mux.respawnPane(paneId, { ...meta, metadata: meta });
755
+ if (existing.panePid !== undefined)
756
+ await state.deleteExitFile(existing);
757
+ } else {
758
+ paneId = await mux.createManagedPane(meta);
759
+ }
760
+ const pane = (await mux.listPanes()).find((p) => p.paneId === paneId && p.taskId === meta.id);
761
+ const timestamp = now();
762
+ const task = {
763
+ id: meta.id,
764
+ role,
765
+ name: meta.name,
766
+ cwd: meta.cwd,
767
+ command,
768
+ sessionId: meta.sessionId,
769
+ source: identity.source ?? existing?.source,
770
+ muxKind: backend.kind,
771
+ socketName: backend.socketName,
772
+ muxSession: pane?.sessionName ?? meta.muxSession,
773
+ paneId,
774
+ panePid: pane?.panePid,
775
+ ...pane ? paneResult(pane, await readExitCode(backend, pane, meta.id)) : { status: "gone" },
776
+ restartCount: existing ? existing.restartCount + 1 : 0,
777
+ createdAt: existing?.createdAt ?? timestamp,
778
+ updatedAt: timestamp
779
+ };
780
+ await state.writeTask(task);
781
+ return task;
782
+ }
783
+ async function runBuild(options) {
784
+ const { wait = true, tailLines = 80 } = options;
785
+ const timeout = duration(options.timeoutMs ?? 120000, "timeoutMs");
786
+ duration(tailLines, "tailLines");
787
+ const identity = { ...options, cwd: resolve2(options.cwd) };
788
+ const channel = wait ? `oc-build-${randomUUID2()}` : undefined;
789
+ const initial = await serial(async () => start("build", identity, options.command, await findNamed("build", identity), channel));
790
+ if (!wait)
791
+ return { ok: initial.status !== "gone", task: initial, tail: "", timedOut: false };
792
+ const mux = await client();
793
+ const controller = new AbortController;
794
+ const deadline = Date.now() + timeout;
795
+ let wake;
796
+ let notifiedAt;
797
+ mux.waitForChannel(channel, { timeoutMs: timeout, signal: controller.signal }).then((signaled) => {
798
+ if (signaled) {
799
+ notifiedAt = Date.now();
800
+ wake?.();
801
+ }
802
+ }, () => {});
803
+ let task = initial;
804
+ try {
805
+ while (task.status === "running" && task.restartCount === initial.restartCount) {
806
+ const remaining = deadline - Date.now();
807
+ if (remaining <= 0)
808
+ break;
809
+ const interval = Math.min(remaining, polling);
810
+ if (notifiedAt !== undefined) {
811
+ await delay(Date.now() - notifiedAt < 250 ? Math.min(interval, 20) : interval);
812
+ } else {
813
+ await new Promise((done) => {
814
+ const timer = setTimeout(done, interval);
815
+ wake = () => {
816
+ clearTimeout(timer);
817
+ done();
818
+ };
819
+ });
820
+ wake = undefined;
821
+ }
822
+ task = await serial(() => find(initial.id)) ?? { ...task, status: "gone" };
823
+ }
824
+ } finally {
825
+ controller.abort();
826
+ }
827
+ const sameRun = task.restartCount === initial.restartCount;
828
+ let tail = "";
829
+ if (sameRun && task.status !== "gone") {
830
+ try {
831
+ tail = await mux.capturePane(task.paneId, tailLines);
832
+ } catch (error) {
833
+ const current = await serial(() => find(task.id));
834
+ if (current && current.status !== "gone" && current.restartCount === task.restartCount)
835
+ throw error;
836
+ task = current ?? { ...task, status: "gone" };
837
+ }
838
+ }
839
+ return {
840
+ ok: task.restartCount === initial.restartCount && task.status === "succeeded",
841
+ task,
842
+ tail,
843
+ timedOut: sameRun && task.status === "running"
844
+ };
845
+ }
846
+ async function stop(task, options) {
847
+ if (task.status !== "running")
848
+ return { ok: task.status !== "gone", task };
849
+ const timeout = duration(options.timeoutMs ?? 2000, "timeoutMs");
850
+ const mux = await client();
851
+ const requested = { ...task, stopRequested: true, updatedAt: now() };
852
+ await state.writeTask(requested);
853
+ try {
854
+ await mux.sendInterrupt(task.paneId);
855
+ } catch (error) {
856
+ const current = await find(task.id);
857
+ if (current?.status !== "running")
858
+ return { ok: current?.status === "stopped", task: current };
859
+ await state.writeTask({ ...current, stopRequested: task.stopRequested });
860
+ throw error;
861
+ }
862
+ const deadline = Date.now() + timeout;
863
+ let current = await find(task.id) ?? requested;
864
+ while (current.status === "running" && current.restartCount === task.restartCount && Date.now() < deadline) {
865
+ await delay(Math.min(polling, Math.max(0, deadline - Date.now())));
866
+ current = await find(task.id) ?? requested;
867
+ }
868
+ if (current.restartCount !== task.restartCount)
869
+ return { ok: false, task: current };
870
+ if (current.status !== "running")
871
+ return { ok: current.status === "stopped", task: current };
872
+ if (!options.force)
873
+ return { ok: false, task: current, timedOut: true };
874
+ await mux.killPane(task.paneId);
875
+ await state.deleteExitFile(task);
876
+ const stopped = { ...current, status: "stopped", forceStopped: true, panePid: undefined, updatedAt: now() };
877
+ await state.writeTask(stopped);
878
+ return { ok: true, task: stopped };
879
+ }
880
+ async function deleteTaskState(task) {
881
+ await state.deleteExitFile(task);
882
+ await state.deleteTask(task.id);
883
+ }
884
+ async function remove(task) {
885
+ const mux = await client();
886
+ if ((await mux.listPanes()).some((pane) => pane.paneId === task.paneId && pane.managed && pane.taskId === task.id)) {
887
+ await mux.killPane(task.paneId);
888
+ }
889
+ await deleteTaskState(task);
890
+ return { ok: true, task };
891
+ }
892
+ async function serviceAction(options) {
893
+ const identity = { ...options, cwd: resolve2(options.cwd) };
894
+ return serial(async () => {
895
+ const task = await findNamed("service", identity);
896
+ switch (options.action) {
897
+ case "status":
898
+ return { ok: !!task, task };
899
+ case "stop":
900
+ return task ? stop(task, options) : { ok: false };
901
+ case "remove":
902
+ return task ? remove(task) : { ok: false };
903
+ case "start":
904
+ if (task?.status === "running" && !options.restartIfRunning)
905
+ return { ok: true, task };
906
+ case "restart": {
907
+ const command = options.command ?? task?.command;
908
+ if (command === undefined)
909
+ throw new Error("A command is required for a new service");
910
+ const started = await start("service", identity, command, task);
911
+ return { ok: started.status !== "gone", task: started };
912
+ }
913
+ }
914
+ });
915
+ }
916
+ function restartTask(id, options = {}) {
917
+ return serial(async () => {
918
+ const task = await find(id);
919
+ if (!task)
920
+ return { ok: false };
921
+ const started = await start(task.role, { ...task, ...options }, options.command ?? task.command, task);
922
+ return { ok: started.status !== "gone", task: started };
923
+ });
924
+ }
925
+ function stopTask(id, options = {}) {
926
+ return serial(async () => {
927
+ const task = await find(id);
928
+ return task ? stop(task, options) : { ok: false };
929
+ });
930
+ }
931
+ function removeTask(id) {
932
+ return serial(async () => {
933
+ const task = await find(id);
934
+ return task ? remove(task) : { ok: false };
935
+ });
936
+ }
937
+ function closeSession({ cwd = process.cwd() } = {}) {
938
+ return serial(async () => {
939
+ const sessionName = projectMuxSession(cwd);
940
+ const tasks = (await reconcile()).filter((task) => task.muxSession === sessionName);
941
+ await (await client()).killSession(sessionName);
942
+ await Promise.all(tasks.map(deleteTaskState));
943
+ return { ok: true, removed: tasks.length, sessionName };
944
+ });
945
+ }
946
+ async function liveTask(id) {
947
+ const task = await find(id);
948
+ if (!task || task.status === "gone" || task.forceStopped) {
949
+ throw new Error(`Mux task ${id} has no live pane`);
950
+ }
951
+ return task;
952
+ }
953
+ return {
954
+ getBackend,
955
+ runBuild,
956
+ serviceAction,
957
+ restartTask,
958
+ stopTask,
959
+ removeTask,
960
+ closeSession,
961
+ captureLogs: (id, lines) => serial(async () => (await client()).capturePane((await liveTask(id)).paneId, lines)),
962
+ sendInput: (id, input, { enter } = {}) => serial(async () => {
963
+ const task = await liveTask(id);
964
+ const mux = await client();
965
+ if (!(await mux.listPanes()).some((pane) => pane.paneId === task.paneId && pane.taskId === id && pane.managed && !pane.paneDead)) {
966
+ throw new Error(`Mux task ${id} has no live pane`);
967
+ }
968
+ await mux.sendKeys(task.paneId, input, enter);
969
+ }),
970
+ listTasks: (filter = {}) => serial(async () => (await reconcile()).filter((task) => matches(task, filter))),
971
+ pruneGone: (filter = {}) => serial(async () => {
972
+ const gone = (await reconcile()).filter((task) => task.status === "gone" && matches(task, filter));
973
+ await Promise.all(gone.map(deleteTaskState));
974
+ return gone;
975
+ }),
976
+ attachCommand: async (task) => buildAttachCommand(await getBackend(), task.muxSession)
977
+ };
978
+ }
979
+ // ../mux/src/tools.ts
980
+ import { resolve as resolve3 } from "node:path";
981
+ var MAX_MUX_INTEGER = 2147483647;
982
+ var ROLES = ["build", "service"];
983
+ var STATUSES = ["running", "succeeded", "failed", "stopped", "gone"];
984
+ var ACTIONS = ["start", "restart", "stop", "status", "remove"];
985
+ var str = (description) => ({ type: "string", description });
986
+ var bool = (description) => ({ type: "boolean", description });
987
+ var integer = (description) => ({ type: "integer", minimum: 0, maximum: MAX_MUX_INTEGER, description });
988
+ var choices = (values, description) => ({ type: "string", enum: values, description });
989
+ var name = str("任务名称。");
990
+ var cwd = str("工作目录;相对路径以当前项目目录为基准。");
991
+ var command = str("在独立终端 pane 中执行的命令。");
992
+ var role = choices(ROLES, "任务类型。");
993
+ var timeoutMs = integer("等待时限(毫秒);超时不会自动终止任务。");
994
+ var tailLines = integer("返回最近的日志行数;0 不抓取日志。");
995
+ var selector = { id: str("唯一任务 ID;提供后优先于名称。"), name, role, cwd };
996
+ function schema(properties, required) {
997
+ return { type: "object", properties, ...required && { required }, additionalProperties: false };
998
+ }
999
+ function report(text, metadata) {
1000
+ return { content: [{ type: "text", text }], metadata };
1001
+ }
1002
+ function tool(name, description, input, execute) {
1003
+ return { name, description, input, execute: (args, context) => execute(args ?? {}, context) };
1004
+ }
1005
+ function taskSummary(task) {
1006
+ const { id, name, role, cwd, status, exitCode, restartCount, muxSession, paneId, shell } = task;
1007
+ return { id, name, role, cwd, status, exitCode: exitCode ?? null, restartCount, muxSession, paneId, ...shell && { shell } };
1008
+ }
1009
+ function taskText(task) {
1010
+ const exit = task.exitCode === null ? "" : ` exitCode=${task.exitCode}`;
1011
+ return `[${task.status}] ${task.role} ${task.name} id=${task.id}${exit}${task.shell ? " shell=驻留" : ""} restartCount=${task.restartCount}` + `
1012
+ cwd=${task.cwd} muxSession=${task.muxSession} paneId=${task.paneId}
1013
+ attach: ${task.attachCommand}`;
1014
+ }
1015
+ function createMuxTools(manager, projectDirectory, defaults = {}) {
1016
+ const workingDirectory = (directory) => resolve3(projectDirectory, directory ?? ".");
1017
+ const origin = (context) => ({ source: "ai", sessionId: context?.sessionID });
1018
+ const attach = async (task) => ({
1019
+ ...taskSummary(task),
1020
+ attachCommand: await manager.attachCommand(task)
1021
+ });
1022
+ async function resolveTask({ id, name, role, cwd }) {
1023
+ if (!id && !name) {
1024
+ return { error: report("请提供任务 id 或 name。可先调用 mux_list 查找任务。", {
1025
+ ok: false,
1026
+ error: "missing_selector"
1027
+ }) };
1028
+ }
1029
+ const matches = id ? (await manager.listTasks()).filter((task) => task.id === id) : await manager.listTasks({ name, role, cwd: cwd === undefined ? undefined : workingDirectory(cwd) });
1030
+ if (matches.length === 0) {
1031
+ return { error: report(`未找到任务 ${id ?? name}。可调用 mux_list 核对任务。`, {
1032
+ ok: false,
1033
+ error: "task_not_found"
1034
+ }) };
1035
+ }
1036
+ if (matches.length > 1) {
1037
+ const candidates = matches.map(taskSummary);
1038
+ return { error: report(`任务名称 ${name} 不唯一。请指定 id,或补充 role/cwd:
1039
+ ` + candidates.map((t) => `- id=${t.id} role=${t.role} cwd=${t.cwd} status=${t.status}`).join(`
1040
+ `), { ok: false, error: "ambiguous_task", candidates }) };
1041
+ }
1042
+ return { task: matches[0] };
1043
+ }
1044
+ async function actionReport(label, result, lines, removed = false) {
1045
+ const { ok, task, timedOut = false } = result;
1046
+ if (!task)
1047
+ return report(`${label}:未找到任务。`, { ok, status: "not_found", timedOut, tail: "" });
1048
+ let tail = "";
1049
+ let tailError;
1050
+ if (!removed && task.status !== "gone" && !task.forceStopped && lines !== 0) {
1051
+ try {
1052
+ tail = await manager.captureLogs(task.id, lines);
1053
+ } catch (error) {
1054
+ tailError = error instanceof Error ? error.message : String(error);
1055
+ }
1056
+ }
1057
+ const info = await attach(task);
1058
+ const status = removed && ok ? "removed" : info.status;
1059
+ return report([
1060
+ `${label}:${status}(ok=${ok})`,
1061
+ taskText(info),
1062
+ timedOut && "等待停止超时;pane 仍可附加,也可以重试停止。",
1063
+ tailError && `未能获取尾部日志:${tailError}`,
1064
+ tail && `日志尾部:
1065
+ ${tail}`
1066
+ ].filter(Boolean).join(`
1067
+ `), {
1068
+ ...info,
1069
+ ok,
1070
+ status,
1071
+ timedOut,
1072
+ tail,
1073
+ ...tailError ? { tailError } : {}
1074
+ });
1075
+ }
1076
+ return [
1077
+ tool("mux_run_build", "运行构建或测试;返回退出状态与日志,保留 pane 供人工查看或重试。", schema({ name, command, cwd, wait: bool("是否等待命令退出;默认 true。"), timeoutMs, tailLines }, ["name", "command"]), async ({ cwd, timeoutMs, tailLines, ...input }, context) => {
1078
+ const result = await manager.runBuild({
1079
+ ...input,
1080
+ cwd: workingDirectory(cwd),
1081
+ ...origin(context),
1082
+ timeoutMs: timeoutMs ?? defaults.defaultTimeoutMs,
1083
+ tailLines: tailLines ?? defaults.defaultTailLines
1084
+ });
1085
+ const info = await attach(result.task);
1086
+ return report([
1087
+ taskText(info),
1088
+ `exitCode=${info.exitCode ?? "未取得"} timedOut=${result.timedOut}`,
1089
+ result.timedOut && "等待构建超时;pane 不会被终止,可人工附加查看或重试。",
1090
+ result.tail && `日志尾部:
1091
+ ${result.tail}`
1092
+ ].filter(Boolean).join(`
1093
+ `), { ...info, ok: result.ok, timedOut: result.timedOut, tail: result.tail });
1094
+ }),
1095
+ tool("mux_service", "启动、重启、停止、查询或移除项目后台服务。", schema({
1096
+ action: choices(ACTIONS, "服务操作;remove 会移除 pane 和任务记录。"),
1097
+ name,
1098
+ command,
1099
+ cwd,
1100
+ restartIfRunning: bool("start 时若已运行,是否重启;默认 false。"),
1101
+ force: bool("stop 等待超时后是否强制关闭 pane;默认 false。"),
1102
+ timeoutMs,
1103
+ tailLines
1104
+ }, ["action", "name"]), async ({ action, cwd, timeoutMs, tailLines, ...input }, context) => {
1105
+ const result = await manager.serviceAction({
1106
+ ...input,
1107
+ action,
1108
+ cwd: workingDirectory(cwd),
1109
+ ...origin(context),
1110
+ timeoutMs: timeoutMs ?? defaults.defaultTimeoutMs
1111
+ });
1112
+ return actionReport(`服务 ${action}`, result, tailLines ?? defaults.defaultTailLines ?? 30, action === "remove" && result.ok);
1113
+ }),
1114
+ tool("mux_restart", "按 ID 或无歧义的名称重启已有构建或服务,可替换命令。", schema({ ...selector, command, tailLines }), async ({ command, tailLines, ...selector }, context) => {
1115
+ const found = await resolveTask(selector);
1116
+ if (found.error)
1117
+ return found.error;
1118
+ const result = await manager.restartTask(found.task.id, { command, ...origin(context) });
1119
+ return actionReport("重启任务", result, tailLines ?? defaults.defaultTailLines ?? 30);
1120
+ }),
1121
+ tool("mux_logs", "按 ID 或无歧义的名称抓取任务日志。", schema({ ...selector, lines: integer("返回最近的日志行数;默认 100。") }), async ({ lines = 100, ...selector }) => {
1122
+ const found = await resolveTask(selector);
1123
+ if (found.error)
1124
+ return found.error;
1125
+ const logs = await manager.captureLogs(found.task.id, lines);
1126
+ const info = await attach(found.task);
1127
+ return report(`${taskText(info)}
1128
+ 日志:
1129
+ ${logs}`, { ...info, ok: true, logs });
1130
+ }),
1131
+ tool("mux_input", "向仍活着的终端 pane 发送字面文本,包括任务退出后驻留的 shell。设 enter: false 可由 AI 输入,人在终端确认后手动按回车。", schema({ ...selector, input: str("发送的文本。可为空,仅发送回车。"), enter: bool("是否发送回车;默认 true。") }, ["input"]), async ({ input, enter = true, ...selector }) => {
1132
+ const found = await resolveTask(selector);
1133
+ if (found.error)
1134
+ return found.error;
1135
+ await manager.sendInput(found.task.id, input, { enter });
1136
+ return report(`已向任务 ${found.task.id} 发送输入(enter=${enter})。`, { ...taskSummary(found.task), ok: true, enter });
1137
+ }),
1138
+ tool("mux_remove", "移除单个构建或服务任务,关闭其 pane 并删除记录。危险:session: true 会关闭 cwd 对应的整个 mux 会话,终止会话中的所有任务并使已附加的终端脱离。", schema({ ...selector, session: bool("关闭整个项目会话;仅使用 cwd 定位,省略 cwd 时使用当前项目。") }), async ({ session, ...selector }) => {
1139
+ if (session) {
1140
+ const result = await manager.closeSession({ cwd: workingDirectory(selector.cwd) });
1141
+ return report(`已关闭会话 ${result.sessionName},清理 ${result.removed} 条任务记录。`, result);
1142
+ }
1143
+ const found = await resolveTask(selector);
1144
+ if (found.error)
1145
+ return found.error;
1146
+ const { ok, task } = await manager.removeTask(found.task.id);
1147
+ if (!ok || !task)
1148
+ return report(`未找到任务 ${found.task.id}。`, { ok: false, error: "task_not_found" });
1149
+ return report(`已移除任务 ${task.id}。`, { ...taskSummary(task), ok, status: "removed" });
1150
+ }),
1151
+ tool("mux_list", "列出受管任务,默认仅当前项目;可清理已丢失 pane 的记录。", schema({
1152
+ cwd,
1153
+ all: bool("未指定 cwd 时,是否查看所有项目。"),
1154
+ role,
1155
+ status: choices(STATUSES, "筛选任务状态。"),
1156
+ pruneGone: bool("先清理目录和角色范围内的 gone 记录,不受 status 筛选影响。")
1157
+ }), async ({ cwd, all, role, status, pruneGone }) => {
1158
+ const filter = {
1159
+ cwd: cwd === undefined && all ? undefined : workingDirectory(cwd),
1160
+ role
1161
+ };
1162
+ const pruned = pruneGone ? await manager.pruneGone(filter) : [];
1163
+ const tasks = await Promise.all((await manager.listTasks({ ...filter, status })).map(attach));
1164
+ return report([
1165
+ `任务范围:${filter.cwd ?? "所有项目"};共 ${tasks.length} 个任务${pruneGone ? `,清理 ${pruned.length} 条记录` : ""}。`,
1166
+ ...tasks.map(taskText)
1167
+ ].join(`
1168
+ `), { ok: true, cwd: filter.cwd ?? null, total: tasks.length, tasks, pruned: pruned.map(taskSummary) });
1169
+ })
1170
+ ];
1171
+ }
1172
+
1173
+ // ../mux/src/index.ts
1174
+ function nonEmptyString(value) {
1175
+ return typeof value === "string" && value.trim() !== "" && !value.includes("\x00") ? value : undefined;
1176
+ }
1177
+ function nonNegativeInteger(value) {
1178
+ return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_MUX_INTEGER ? value : undefined;
1179
+ }
1180
+ function parseMuxOptions(options) {
1181
+ const values = options && typeof options === "object" ? options : {};
1182
+ return {
1183
+ preferred: values.preferred === "tmux" || values.preferred === "psmux" ? values.preferred : undefined,
1184
+ socketName: nonEmptyString(values.socketName),
1185
+ stateDir: nonEmptyString(values.stateDir),
1186
+ keepShellOnExit: typeof values.keepShellOnExit === "boolean" ? values.keepShellOnExit : undefined,
1187
+ byobuKeys: typeof values.byobuKeys === "boolean" ? values.byobuKeys : undefined,
1188
+ statusTheme: values.statusTheme === "powerline" || values.statusTheme === "ascii" || values.statusTheme === "off" ? values.statusTheme : undefined,
1189
+ defaultTimeoutMs: nonNegativeInteger(values.defaultTimeoutMs),
1190
+ defaultTailLines: nonNegativeInteger(values.defaultTailLines)
1191
+ };
1192
+ }
1193
+ var MuxPlugin = {
1194
+ id: "opencode-mux",
1195
+ async setup(ctx) {
1196
+ const cwd = resolve4(ctx.location?.directory ?? process.cwd());
1197
+ const { preferred, socketName, stateDir, keepShellOnExit, byobuKeys, statusTheme, ...defaults } = parseMuxOptions(ctx.options);
1198
+ const manager = createMuxManager({
1199
+ preferred,
1200
+ socketName,
1201
+ stateDir: stateDir && resolve4(cwd, stateDir),
1202
+ keepShellOnExit,
1203
+ byobuKeys,
1204
+ statusTheme
1205
+ });
1206
+ const tools = createMuxTools(manager, cwd, defaults);
1207
+ await ctx.tool.transform((editor) => {
1208
+ for (const tool of tools) {
1209
+ if (!editor.list().some((entry) => entry.name === tool.name))
1210
+ editor.add(tool);
1211
+ }
1212
+ });
1213
+ }
1214
+ };
1215
+ var src_default = MuxPlugin;
1216
+ export {
1217
+ MuxPlugin,
1218
+ createMuxTools,
1219
+ src_default as default,
1220
+ parseMuxOptions
1221
+ };