@sirenodeck/sirenodeck 0.2.5 → 0.2.6
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/dist/capture-file-C11RW9NA.mjs +47 -0
- package/dist/darwin-B1ECvuGg.mjs +15 -0
- package/dist/darwin-Bs7hyOFv.mjs +78 -0
- package/dist/darwin-Cm-RiXMK.mjs +56 -0
- package/dist/darwin-DCTL6wDT.mjs +39 -0
- package/dist/darwin-RFhh5cL5.mjs +122 -0
- package/dist/install-yAoVCzK1.mjs +198 -0
- package/dist/linux-BDSwIJbc.mjs +577 -0
- package/dist/linux-CS_pCg0V.mjs +158 -0
- package/dist/linux-Dq07aXcR.mjs +119 -0
- package/dist/linux-OyPmXbFE.mjs +51 -0
- package/dist/live-metrics-CMf02ncg.mjs +975 -0
- package/dist/main.mjs +1 -1
- package/dist/spawn-IWeEQPpd.mjs +69 -0
- package/dist/windows-CRWdUgCn.mjs +45 -0
- package/dist/windows-CTAfiwO_.mjs +361 -0
- package/dist/windows-DeS97h4f.mjs +74 -0
- package/dist/windows-zhWiv_h8.mjs +55 -0
- package/package.json +2 -2
package/dist/main.mjs
CHANGED
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
import { execa } from "execa";
|
|
2
|
+
//#region src/builtin-addons/coding-agents/providers/spawn.ts
|
|
3
|
+
var NotReachableError = class extends Error {
|
|
4
|
+
name = "NotReachableError";
|
|
5
|
+
constructor(message) {
|
|
6
|
+
super(message);
|
|
7
|
+
}
|
|
8
|
+
};
|
|
9
|
+
const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
10
|
+
const ensureOpencodeServer = async (baseUrl, signal, deps = {}) => {
|
|
11
|
+
const fetchImpl = deps.fetchImpl ?? fetch;
|
|
12
|
+
const sleep = deps.sleep ?? defaultSleep;
|
|
13
|
+
if (await isReachable(baseUrl, fetchImpl, signal)) return null;
|
|
14
|
+
if (signal.aborted) throw new AbortError();
|
|
15
|
+
const port = parsePort(baseUrl);
|
|
16
|
+
const child = deps.execaImpl ? deps.execaImpl("opencode", [
|
|
17
|
+
"serve",
|
|
18
|
+
"--port",
|
|
19
|
+
String(port)
|
|
20
|
+
]) : execa("opencode", [
|
|
21
|
+
"serve",
|
|
22
|
+
"--port",
|
|
23
|
+
String(port)
|
|
24
|
+
]);
|
|
25
|
+
Promise.resolve(child).catch(() => void 0);
|
|
26
|
+
const deadline = Date.now() + 5e3;
|
|
27
|
+
while (Date.now() < deadline) {
|
|
28
|
+
if (signal.aborted) {
|
|
29
|
+
await child.kill().catch(() => void 0);
|
|
30
|
+
throw new AbortError();
|
|
31
|
+
}
|
|
32
|
+
if (await isReachable(baseUrl, fetchImpl, signal)) return {
|
|
33
|
+
baseUrl,
|
|
34
|
+
child: { kill: async () => {
|
|
35
|
+
await child.kill().catch(() => void 0);
|
|
36
|
+
} }
|
|
37
|
+
};
|
|
38
|
+
await sleep(200);
|
|
39
|
+
}
|
|
40
|
+
await child.kill().catch(() => void 0);
|
|
41
|
+
throw new NotReachableError(`opencode serve did not become reachable at ${baseUrl} within 5 s`);
|
|
42
|
+
};
|
|
43
|
+
const isReachable = async (baseUrl, fetchImpl, signal) => {
|
|
44
|
+
try {
|
|
45
|
+
const res = await fetchImpl(`${baseUrl}/global/health`, { signal });
|
|
46
|
+
if (!res.ok) return false;
|
|
47
|
+
return (await res.json()).healthy === true;
|
|
48
|
+
} catch (err) {
|
|
49
|
+
if (err?.shortMessage) return false;
|
|
50
|
+
return false;
|
|
51
|
+
}
|
|
52
|
+
};
|
|
53
|
+
const parsePort = (baseUrl) => {
|
|
54
|
+
try {
|
|
55
|
+
const parsed = new URL(baseUrl);
|
|
56
|
+
const port = Number.parseInt(parsed.port, 10);
|
|
57
|
+
return Number.isFinite(port) && port > 0 ? port : 4096;
|
|
58
|
+
} catch {
|
|
59
|
+
return 4096;
|
|
60
|
+
}
|
|
61
|
+
};
|
|
62
|
+
var AbortError = class extends Error {
|
|
63
|
+
name = "AbortError";
|
|
64
|
+
constructor() {
|
|
65
|
+
super("aborted");
|
|
66
|
+
}
|
|
67
|
+
};
|
|
68
|
+
//#endregion
|
|
69
|
+
export { ensureOpencodeServer };
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
import { a as withTimeout } from "./main.mjs";
|
|
2
|
+
//#region src/system/providers/notification/windows.ts
|
|
3
|
+
const DEFAULT_TIMEOUT_MS = 5e3;
|
|
4
|
+
const shellQuote = (value) => `'${value.replace(/'/g, "''").replace(/'/g, "'\\''")}'`;
|
|
5
|
+
const buildToastScript = (title, body) => {
|
|
6
|
+
const safeTitle = title.replace(/[`$"\\]/g, "\\$&");
|
|
7
|
+
const safeBody = body.replace(/[`$"\\]/g, "\\$&");
|
|
8
|
+
return [
|
|
9
|
+
"Add-Type -AssemblyName System.Windows.Forms | Out-Null",
|
|
10
|
+
`$balloon = New-Object System.Windows.Forms.NotifyIcon`,
|
|
11
|
+
`$balloon.Icon = [System.Drawing.SystemIcons]::Information`,
|
|
12
|
+
`$balloon.BalloonTipTitle = "${safeTitle}"`,
|
|
13
|
+
`$balloon.BalloonTipText = "${safeBody}"`,
|
|
14
|
+
`$balloon.Visible = $true`,
|
|
15
|
+
`$balloon.ShowBalloonTip(5000)`,
|
|
16
|
+
"Start-Sleep -Milliseconds 5500",
|
|
17
|
+
"$balloon.Dispose()"
|
|
18
|
+
].join("; ");
|
|
19
|
+
};
|
|
20
|
+
const createWindowsNotificationProvider = async (deps) => {
|
|
21
|
+
const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
22
|
+
return { async notify(args) {
|
|
23
|
+
const script = buildToastScript(args.title, args.body);
|
|
24
|
+
try {
|
|
25
|
+
await withTimeout(deps.executor.run("powershell", [
|
|
26
|
+
"-NoProfile",
|
|
27
|
+
"-Command",
|
|
28
|
+
script
|
|
29
|
+
]), timeoutMs);
|
|
30
|
+
} catch (err) {
|
|
31
|
+
deps.logger.warn({ err }, "windows notification: toast failed");
|
|
32
|
+
}
|
|
33
|
+
if (args.sound === true && deps.soundPath !== void 0) try {
|
|
34
|
+
await withTimeout(deps.executor.run("powershell", [
|
|
35
|
+
"-NoProfile",
|
|
36
|
+
"-Command",
|
|
37
|
+
`(New-Object Media.SoundPlayer '${shellQuote(deps.soundPath)}').PlaySync()`
|
|
38
|
+
]), timeoutMs);
|
|
39
|
+
} catch (err) {
|
|
40
|
+
deps.logger.warn({ err }, "windows notification: sound playback failed");
|
|
41
|
+
}
|
|
42
|
+
} };
|
|
43
|
+
};
|
|
44
|
+
//#endregion
|
|
45
|
+
export { createWindowsNotificationProvider };
|
|
@@ -0,0 +1,361 @@
|
|
|
1
|
+
import { a as withTimeout, o as ProviderError, s as parseCombo } from "./main.mjs";
|
|
2
|
+
import { join } from "node:path";
|
|
3
|
+
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
4
|
+
import { createHash } from "node:crypto";
|
|
5
|
+
import { tmpdir } from "node:os";
|
|
6
|
+
//#region src/system/providers/key-macro/windows.ts
|
|
7
|
+
const CACHE_DIR = join(tmpdir(), "sirenodeck", "key-macro-windows");
|
|
8
|
+
const HELPER_DLL = join(CACHE_DIR, "sirenokey-input.dll");
|
|
9
|
+
const HELPER_SRC_HASH = join(CACHE_DIR, "sirenokey-input.dll.src.sha256");
|
|
10
|
+
const sourceHash = (src) => createHash("sha256").update(src, "utf8").digest("hex");
|
|
11
|
+
const readCachedHash = () => {
|
|
12
|
+
try {
|
|
13
|
+
return readFileSync(HELPER_SRC_HASH, "utf8").trim();
|
|
14
|
+
} catch {
|
|
15
|
+
return null;
|
|
16
|
+
}
|
|
17
|
+
};
|
|
18
|
+
const writeCachedHash = (hash) => {
|
|
19
|
+
try {
|
|
20
|
+
writeFileSync(HELPER_SRC_HASH, `${hash}\n`, "utf8");
|
|
21
|
+
} catch {}
|
|
22
|
+
};
|
|
23
|
+
const HELPED_SOURCE = String.raw`
|
|
24
|
+
using System;
|
|
25
|
+
using System.Collections.Generic;
|
|
26
|
+
using System.Runtime.InteropServices;
|
|
27
|
+
|
|
28
|
+
public static class SirenoKey
|
|
29
|
+
{
|
|
30
|
+
[DllImport("user32.dll", SetLastError = true)]
|
|
31
|
+
static extern uint SendInput(uint n, INPUT[] p, int cb);
|
|
32
|
+
|
|
33
|
+
[StructLayout(LayoutKind.Sequential)]
|
|
34
|
+
struct INPUT { public uint type; public INPUTUNION u; }
|
|
35
|
+
|
|
36
|
+
[StructLayout(LayoutKind.Explicit)]
|
|
37
|
+
struct INPUTUNION {
|
|
38
|
+
[FieldOffset(0)] public KEYBDINPUT k;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
[StructLayout(LayoutKind.Sequential)]
|
|
42
|
+
struct KEYBDINPUT {
|
|
43
|
+
public ushort wVk;
|
|
44
|
+
public ushort wScan;
|
|
45
|
+
public uint dwFlags;
|
|
46
|
+
public uint time;
|
|
47
|
+
public IntPtr dwExtraInfo;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
const uint INPUT_KEYBOARD = 1;
|
|
51
|
+
const ushort KEYEVENTF_UNICODE = 0x0004;
|
|
52
|
+
const ushort KEYEVENTF_KEYUP = 0x0002;
|
|
53
|
+
const ushort KEYEVENTF_EXTENDEDKEY = 0x0001;
|
|
54
|
+
|
|
55
|
+
static bool IsExtended(ushort vk) {
|
|
56
|
+
return vk == 0x21 || vk == 0x22 || vk == 0x23 || vk == 0x24
|
|
57
|
+
|| vk == 0x25 || vk == 0x26 || vk == 0x27 || vk == 0x28
|
|
58
|
+
|| vk == 0x2D || vk == 0x2E
|
|
59
|
+
|| vk == 0x6F || vk == 0x0D
|
|
60
|
+
|| vk == 0xA3 || vk == 0xA5;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
static INPUT MkDown(ushort vk) {
|
|
64
|
+
var i = new INPUT();
|
|
65
|
+
i.type = INPUT_KEYBOARD;
|
|
66
|
+
i.u.k.wVk = vk;
|
|
67
|
+
i.u.k.dwFlags = (uint)(IsExtended(vk) ? KEYEVENTF_EXTENDEDKEY : 0);
|
|
68
|
+
return i;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
static INPUT MkUp(ushort vk) {
|
|
72
|
+
var i = new INPUT();
|
|
73
|
+
i.type = INPUT_KEYBOARD;
|
|
74
|
+
i.u.k.wVk = vk;
|
|
75
|
+
i.u.k.dwFlags = (uint)((IsExtended(vk) ? KEYEVENTF_EXTENDEDKEY : 0) | KEYEVENTF_KEYUP);
|
|
76
|
+
return i;
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
static string Err(int expected, uint sent) {
|
|
80
|
+
int err = Marshal.GetLastWin32Error();
|
|
81
|
+
return "fail:" + err + ":SendInput returned " + sent + " of " + expected;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
static uint Send(INPUT[] arr) {
|
|
85
|
+
return SendInput((uint)arr.Length, arr, Marshal.SizeOf(typeof(INPUT)));
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
public static string TypeText(string s) {
|
|
89
|
+
if (s == null) s = "";
|
|
90
|
+
var inputs = new List<INPUT>();
|
|
91
|
+
foreach (var ch in s) {
|
|
92
|
+
ushort sc = (ushort)ch;
|
|
93
|
+
var down = new INPUT();
|
|
94
|
+
down.type = INPUT_KEYBOARD;
|
|
95
|
+
down.u.k.wVk = 0;
|
|
96
|
+
down.u.k.wScan = sc;
|
|
97
|
+
down.u.k.dwFlags = KEYEVENTF_UNICODE;
|
|
98
|
+
inputs.Add(down);
|
|
99
|
+
var up = new INPUT();
|
|
100
|
+
up.type = INPUT_KEYBOARD;
|
|
101
|
+
up.u.k.wVk = 0;
|
|
102
|
+
up.u.k.wScan = sc;
|
|
103
|
+
up.u.k.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP;
|
|
104
|
+
inputs.Add(up);
|
|
105
|
+
}
|
|
106
|
+
var arr = inputs.ToArray();
|
|
107
|
+
if (arr.Length == 0) return "ok:0:";
|
|
108
|
+
uint sent = Send(arr);
|
|
109
|
+
if (sent != arr.Length) return Err(arr.Length, sent);
|
|
110
|
+
return "ok:0:";
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
public static string TapKey(ushort vk) {
|
|
114
|
+
var arr = new INPUT[] { MkDown(vk), MkUp(vk) };
|
|
115
|
+
uint sent = Send(arr);
|
|
116
|
+
if (sent != (uint)arr.Length) return Err(arr.Length, sent);
|
|
117
|
+
return "ok:0:";
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
public static string KeyDown(ushort vk) {
|
|
121
|
+
var arr = new INPUT[] { MkDown(vk) };
|
|
122
|
+
uint sent = Send(arr);
|
|
123
|
+
if (sent != (uint)arr.Length) return Err(arr.Length, sent);
|
|
124
|
+
return "ok:0:";
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
public static string KeyUp(ushort vk) {
|
|
128
|
+
var arr = new INPUT[] { MkUp(vk) };
|
|
129
|
+
uint sent = Send(arr);
|
|
130
|
+
if (sent != (uint)arr.Length) return Err(arr.Length, sent);
|
|
131
|
+
return "ok:0:";
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
`;
|
|
135
|
+
const COMPILE_PS = (cacheDir, dllPath) => `
|
|
136
|
+
$ErrorActionPreference = 'Stop'
|
|
137
|
+
$src = @'
|
|
138
|
+
${HELPED_SOURCE}
|
|
139
|
+
'@
|
|
140
|
+
try {
|
|
141
|
+
Add-Type -TypeDefinition $src -Language CSharp
|
|
142
|
+
$asm = [SirenoKey].Assembly.Location
|
|
143
|
+
if (-not (Test-Path '${escapeForPSSingleQuote(cacheDir)}')) {
|
|
144
|
+
New-Item -ItemType Directory -Path '${escapeForPSSingleQuote(cacheDir)}' -Force | Out-Null
|
|
145
|
+
}
|
|
146
|
+
Copy-Item -Path $asm -Destination '${escapeForPSSingleQuote(dllPath)}' -Force
|
|
147
|
+
exit 0
|
|
148
|
+
} catch {
|
|
149
|
+
[Console]::Error.WriteLine($_.Exception.Message)
|
|
150
|
+
exit 1
|
|
151
|
+
}
|
|
152
|
+
`;
|
|
153
|
+
const escapeForPSSingleQuote = (s) => s.replace(/'/g, "''");
|
|
154
|
+
const encodePSCommand = (script) => {
|
|
155
|
+
return Buffer.from(script, "utf16le").toString("base64");
|
|
156
|
+
};
|
|
157
|
+
const VK_CONTROL = 17;
|
|
158
|
+
const VK_SHIFT = 16;
|
|
159
|
+
const VK_MENU = 18;
|
|
160
|
+
const VK_LWIN = 91;
|
|
161
|
+
const VK_NAMED = /* @__PURE__ */ new Map([
|
|
162
|
+
["Return", 13],
|
|
163
|
+
["Tab", 9],
|
|
164
|
+
["Escape", 27],
|
|
165
|
+
["BackSpace", 8],
|
|
166
|
+
["Delete", 46],
|
|
167
|
+
["Insert", 45],
|
|
168
|
+
["Home", 36],
|
|
169
|
+
["End", 35],
|
|
170
|
+
["Page_Up", 33],
|
|
171
|
+
["Page_Down", 34],
|
|
172
|
+
["Up", 38],
|
|
173
|
+
["Down", 40],
|
|
174
|
+
["Left", 37],
|
|
175
|
+
["Right", 39],
|
|
176
|
+
["space", 32],
|
|
177
|
+
["F1", 112],
|
|
178
|
+
["F2", 113],
|
|
179
|
+
["F3", 114],
|
|
180
|
+
["F4", 115],
|
|
181
|
+
["F5", 116],
|
|
182
|
+
["F6", 117],
|
|
183
|
+
["F7", 118],
|
|
184
|
+
["F8", 119],
|
|
185
|
+
["F9", 120],
|
|
186
|
+
["F10", 121],
|
|
187
|
+
["F11", 122],
|
|
188
|
+
["F12", 123],
|
|
189
|
+
["F13", 124],
|
|
190
|
+
["F14", 125],
|
|
191
|
+
["F15", 126],
|
|
192
|
+
["F16", 127],
|
|
193
|
+
["F17", 128],
|
|
194
|
+
["F18", 129],
|
|
195
|
+
["F19", 130],
|
|
196
|
+
["F20", 131],
|
|
197
|
+
["F21", 132],
|
|
198
|
+
["F22", 133],
|
|
199
|
+
["F23", 134],
|
|
200
|
+
["F24", 135],
|
|
201
|
+
["Caps_Lock", 20],
|
|
202
|
+
["Num_Lock", 144],
|
|
203
|
+
["Scroll_Lock", 145],
|
|
204
|
+
["Pause", 19],
|
|
205
|
+
["Menu", 93],
|
|
206
|
+
["Print", 42],
|
|
207
|
+
["plus", 187],
|
|
208
|
+
["minus", 189],
|
|
209
|
+
["equal", 187],
|
|
210
|
+
["comma", 188],
|
|
211
|
+
["period", 190]
|
|
212
|
+
]);
|
|
213
|
+
const MOD_TO_VK = /* @__PURE__ */ new Map([
|
|
214
|
+
["ctrl", VK_CONTROL],
|
|
215
|
+
["shift", VK_SHIFT],
|
|
216
|
+
["alt", VK_MENU],
|
|
217
|
+
["meta", VK_LWIN],
|
|
218
|
+
["super", VK_LWIN],
|
|
219
|
+
["hyper", VK_LWIN]
|
|
220
|
+
]);
|
|
221
|
+
const MOD_ORDER = [
|
|
222
|
+
"ctrl",
|
|
223
|
+
"alt",
|
|
224
|
+
"shift",
|
|
225
|
+
"super"
|
|
226
|
+
];
|
|
227
|
+
const modToVk = (mod) => MOD_TO_VK.get(mod) ?? null;
|
|
228
|
+
const keyToVk = (key) => {
|
|
229
|
+
const named = VK_NAMED.get(key);
|
|
230
|
+
if (named !== void 0) return named;
|
|
231
|
+
if (key.length === 1) {
|
|
232
|
+
const code = key.charCodeAt(0);
|
|
233
|
+
if (code >= 97 && code <= 122) return code - 32;
|
|
234
|
+
if (code >= 48 && code <= 57) return code;
|
|
235
|
+
}
|
|
236
|
+
return null;
|
|
237
|
+
};
|
|
238
|
+
const escapeForPSDoubleQuote = (s) => s.replace(/[\\"$`]/g, "``$&");
|
|
239
|
+
const compileHelper = async (deps) => {
|
|
240
|
+
if (!existsSync(CACHE_DIR)) try {
|
|
241
|
+
mkdirSync(CACHE_DIR, { recursive: true });
|
|
242
|
+
} catch (err) {
|
|
243
|
+
deps.logger.warn({
|
|
244
|
+
err,
|
|
245
|
+
cacheDir: CACHE_DIR
|
|
246
|
+
}, "windows key-macro: failed to create cache dir");
|
|
247
|
+
return null;
|
|
248
|
+
}
|
|
249
|
+
const expectedHash = sourceHash(HELPED_SOURCE);
|
|
250
|
+
if (readCachedHash() === expectedHash && existsSync(HELPER_DLL)) {
|
|
251
|
+
deps.logger.debug({ dllPath: HELPER_DLL }, "windows key-macro: using cached DLL (source hash unchanged)");
|
|
252
|
+
return { dllPath: HELPER_DLL };
|
|
253
|
+
}
|
|
254
|
+
const script = COMPILE_PS(CACHE_DIR, HELPER_DLL);
|
|
255
|
+
const encoded = encodePSCommand(script);
|
|
256
|
+
try {
|
|
257
|
+
const result = await deps.executor.run("powershell", [
|
|
258
|
+
"-NoProfile",
|
|
259
|
+
"-EncodedCommand",
|
|
260
|
+
encoded
|
|
261
|
+
]);
|
|
262
|
+
if (result.exitCode !== 0) {
|
|
263
|
+
deps.logger.warn({ stderr: result.stderr.trim() }, "windows key-macro: helper compile failed");
|
|
264
|
+
return null;
|
|
265
|
+
}
|
|
266
|
+
} catch (err) {
|
|
267
|
+
deps.logger.warn({ err }, "windows key-macro: helper compile threw");
|
|
268
|
+
return null;
|
|
269
|
+
}
|
|
270
|
+
if (!existsSync(HELPER_DLL)) {
|
|
271
|
+
deps.logger.warn({ dllPath: HELPER_DLL }, "windows key-macro: helper DLL missing after compile");
|
|
272
|
+
return null;
|
|
273
|
+
}
|
|
274
|
+
writeCachedHash(expectedHash);
|
|
275
|
+
return { dllPath: HELPER_DLL };
|
|
276
|
+
};
|
|
277
|
+
const buildTypeTextPS = (dllPath, text) => {
|
|
278
|
+
const escapedText = escapeForPSDoubleQuote(text);
|
|
279
|
+
return `[Reflection.Assembly]::LoadFrom('${escapeForPSSingleQuote(dllPath)}') | Out-Null
|
|
280
|
+
$r = [SirenoKey]::TypeText("${escapedText}")
|
|
281
|
+
Write-Output $r
|
|
282
|
+
`;
|
|
283
|
+
};
|
|
284
|
+
const buildComboPS = (dllPath, orderedMods, keyVk) => {
|
|
285
|
+
const dllEsc = escapeForPSSingleQuote(dllPath);
|
|
286
|
+
const lines = [];
|
|
287
|
+
lines.push(`[Reflection.Assembly]::LoadFrom('${dllEsc}') | Out-Null`);
|
|
288
|
+
for (const vk of orderedMods) lines.push(`$null = [SirenoKey]::KeyDown(${vk})`);
|
|
289
|
+
lines.push(`$null = [SirenoKey]::TapKey(${keyVk})`);
|
|
290
|
+
for (const vk of [...orderedMods].reverse()) lines.push(`$null = [SirenoKey]::KeyUp(${vk})`);
|
|
291
|
+
lines.push(`Write-Output 'ok:0:'`);
|
|
292
|
+
return lines.join("\n") + "\n";
|
|
293
|
+
};
|
|
294
|
+
const parseResponse = (stdout) => {
|
|
295
|
+
const m = stdout.match(/^(ok|fail):(\d+):(.*)$/);
|
|
296
|
+
if (m === null) return null;
|
|
297
|
+
return {
|
|
298
|
+
ok: m[1] === "ok",
|
|
299
|
+
win32: Number(m[2]),
|
|
300
|
+
message: m[3] ?? ""
|
|
301
|
+
};
|
|
302
|
+
};
|
|
303
|
+
const sendViaPowerShell = async (script, deps) => {
|
|
304
|
+
const timeoutMs = deps.timeoutMs ?? 500;
|
|
305
|
+
const encoded = encodePSCommand(script);
|
|
306
|
+
const result = await withTimeout(deps.executor.run("powershell", [
|
|
307
|
+
"-NoProfile",
|
|
308
|
+
"-EncodedCommand",
|
|
309
|
+
encoded
|
|
310
|
+
]), timeoutMs + 2500);
|
|
311
|
+
if (result.exitCode !== 0) throw new ProviderError("EXEC_FAILED", `powershell exited ${result.exitCode}: ${result.stderr.trim() || result.stdout.trim()}`);
|
|
312
|
+
const parsed = parseResponse(result.stdout.trim());
|
|
313
|
+
if (parsed === null) throw new ProviderError("EXEC_FAILED", `unexpected SendInput response: ${result.stdout.trim().slice(0, 200)}`);
|
|
314
|
+
if (!parsed.ok) throw new ProviderError("EXEC_FAILED", `SendInput failed (Win32 #${parsed.win32}): ${parsed.message}`);
|
|
315
|
+
return parsed;
|
|
316
|
+
};
|
|
317
|
+
const createWindowsKeyMacroProvider = async (deps) => {
|
|
318
|
+
const helper = await compileHelper(deps);
|
|
319
|
+
if (helper === null) return {
|
|
320
|
+
async sendKey(_input) {
|
|
321
|
+
throw new ProviderError("NOT_AVAILABLE", "Windows key-macro unavailable: failed to compile SendInput helper (PowerShell Add-Type failed). Check that PowerShell 5+ is on PATH and user32.dll is reachable.");
|
|
322
|
+
},
|
|
323
|
+
async stop() {}
|
|
324
|
+
};
|
|
325
|
+
deps.logger.info({ dllPath: helper.dllPath }, "Windows key-macro provider initialised (Win32 SendInput)");
|
|
326
|
+
return {
|
|
327
|
+
async sendKey(input) {
|
|
328
|
+
const parsed = parseCombo(input);
|
|
329
|
+
if (parsed !== null) {
|
|
330
|
+
const seenVk = /* @__PURE__ */ new Set();
|
|
331
|
+
const orderedMods = [];
|
|
332
|
+
const mods = (parsed.key === "plus" || parsed.key === "minus") && !parsed.mods.includes("shift") ? [...parsed.mods, "shift"] : parsed.mods;
|
|
333
|
+
for (const mod of MOD_ORDER) {
|
|
334
|
+
if (!mods.includes(mod)) continue;
|
|
335
|
+
const vk = modToVk(mod);
|
|
336
|
+
if (vk === null) throw new ProviderError("EXEC_FAILED", `windows: cannot map modifier '${mod}' to VK code`);
|
|
337
|
+
if (seenVk.has(vk)) continue;
|
|
338
|
+
seenVk.add(vk);
|
|
339
|
+
orderedMods.push(vk);
|
|
340
|
+
}
|
|
341
|
+
for (const mod of mods) {
|
|
342
|
+
const vk = modToVk(mod);
|
|
343
|
+
if (vk === null) throw new ProviderError("EXEC_FAILED", `windows: cannot map modifier '${mod}' to VK code`);
|
|
344
|
+
if (seenVk.has(vk)) continue;
|
|
345
|
+
seenVk.add(vk);
|
|
346
|
+
orderedMods.push(vk);
|
|
347
|
+
}
|
|
348
|
+
const keyVk = keyToVk(parsed.key);
|
|
349
|
+
if (keyVk === null) throw new ProviderError("EXEC_FAILED", `windows: cannot map key '${parsed.key}' to VK code (combo keys must be alphanumeric or a named key)`);
|
|
350
|
+
const script = buildComboPS(helper.dllPath, orderedMods, keyVk);
|
|
351
|
+
await sendViaPowerShell(script, deps);
|
|
352
|
+
return;
|
|
353
|
+
}
|
|
354
|
+
const script = buildTypeTextPS(helper.dllPath, input);
|
|
355
|
+
await sendViaPowerShell(script, deps);
|
|
356
|
+
},
|
|
357
|
+
async stop() {}
|
|
358
|
+
};
|
|
359
|
+
};
|
|
360
|
+
//#endregion
|
|
361
|
+
export { createWindowsKeyMacroProvider };
|
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
//#region src/system/providers/active-app/windows.ts
|
|
2
|
+
const DEFAULT_POLL_MS = 1e3;
|
|
3
|
+
const PS_GET_ACTIVE = `Add-Type -AssemblyName UIAutomationClient,UIAutomationTypes; $el=[System.Windows.Automation.AutomationElement]::FocusedElement; "{0}|{1}" -f $el.Current.Name, $el.Current.ProcessId`;
|
|
4
|
+
const parseOutput = (raw) => {
|
|
5
|
+
const trimmed = raw.trim();
|
|
6
|
+
if (trimmed.length === 0) return null;
|
|
7
|
+
const idx = trimmed.lastIndexOf("|");
|
|
8
|
+
if (idx < 0) return null;
|
|
9
|
+
const name = trimmed.substring(0, idx).trim();
|
|
10
|
+
const pidStr = trimmed.substring(idx + 1).trim();
|
|
11
|
+
const pid = Number.parseInt(pidStr, 10);
|
|
12
|
+
if (name.length === 0) return null;
|
|
13
|
+
return {
|
|
14
|
+
name,
|
|
15
|
+
pid: Number.isFinite(pid) ? pid : null
|
|
16
|
+
};
|
|
17
|
+
};
|
|
18
|
+
const createWindowsActiveAppProvider = async (deps) => {
|
|
19
|
+
const pollMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS;
|
|
20
|
+
const subscribers = /* @__PURE__ */ new Set();
|
|
21
|
+
let last = null;
|
|
22
|
+
let stopped = false;
|
|
23
|
+
const snapshot = async () => {
|
|
24
|
+
try {
|
|
25
|
+
const result = await deps.executor.run("powershell", [
|
|
26
|
+
"-NoProfile",
|
|
27
|
+
"-Command",
|
|
28
|
+
PS_GET_ACTIVE
|
|
29
|
+
], { timeoutMs: 3e3 });
|
|
30
|
+
if (result.exitCode !== 0) return last;
|
|
31
|
+
const parsed = parseOutput(result.stdout);
|
|
32
|
+
if (parsed === null) return last;
|
|
33
|
+
return {
|
|
34
|
+
name: parsed.name,
|
|
35
|
+
windowTitle: parsed.name,
|
|
36
|
+
processId: parsed.pid
|
|
37
|
+
};
|
|
38
|
+
} catch (err) {
|
|
39
|
+
deps.logger.warn({ err }, "active-app: powershell failed");
|
|
40
|
+
return last;
|
|
41
|
+
}
|
|
42
|
+
};
|
|
43
|
+
let interval = null;
|
|
44
|
+
interval = setInterval(() => {
|
|
45
|
+
if (stopped) return;
|
|
46
|
+
snapshot().then((s) => {
|
|
47
|
+
if (stopped) return;
|
|
48
|
+
if (!(last !== null && s !== null && last.name === s.name && last.processId === s.processId)) {
|
|
49
|
+
last = s;
|
|
50
|
+
for (const h of subscribers) h(s);
|
|
51
|
+
}
|
|
52
|
+
});
|
|
53
|
+
}, pollMs);
|
|
54
|
+
return {
|
|
55
|
+
async getActive() {
|
|
56
|
+
return snapshot();
|
|
57
|
+
},
|
|
58
|
+
subscribe(handler) {
|
|
59
|
+
subscribers.add(handler);
|
|
60
|
+
return () => {
|
|
61
|
+
subscribers.delete(handler);
|
|
62
|
+
};
|
|
63
|
+
},
|
|
64
|
+
async stop() {
|
|
65
|
+
stopped = true;
|
|
66
|
+
if (interval !== null) {
|
|
67
|
+
clearInterval(interval);
|
|
68
|
+
interval = null;
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
};
|
|
72
|
+
};
|
|
73
|
+
//#endregion
|
|
74
|
+
export { createWindowsActiveAppProvider };
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
//#region src/system/providers/session/windows.ts
|
|
2
|
+
const toState = (locked) => locked ? "locked" : "unlocked";
|
|
3
|
+
const PS_GET_LOGONUI = `if (Get-Process logonui -ErrorAction SilentlyContinue) { 'true' } else { 'false' }`;
|
|
4
|
+
const parseLockResult = (raw) => raw.trim().toLowerCase() === "true";
|
|
5
|
+
const createWindowsSessionProvider = async (deps) => {
|
|
6
|
+
const listeners = /* @__PURE__ */ new Set();
|
|
7
|
+
let state = "unknown";
|
|
8
|
+
let stopped = false;
|
|
9
|
+
const pollMs = deps.pollIntervalMs ?? 5e3;
|
|
10
|
+
const tick = async () => {
|
|
11
|
+
try {
|
|
12
|
+
const result = await deps.executor.run("powershell", [
|
|
13
|
+
"-NoProfile",
|
|
14
|
+
"-Command",
|
|
15
|
+
PS_GET_LOGONUI
|
|
16
|
+
], { timeoutMs: 2e3 });
|
|
17
|
+
if (result.exitCode !== 0) return state;
|
|
18
|
+
return toState(parseLockResult(result.stdout));
|
|
19
|
+
} catch (err) {
|
|
20
|
+
deps.logger.debug({ err }, "session: powershell failed");
|
|
21
|
+
return state;
|
|
22
|
+
}
|
|
23
|
+
};
|
|
24
|
+
state = await tick();
|
|
25
|
+
let interval = setInterval(() => {
|
|
26
|
+
if (stopped) return;
|
|
27
|
+
tick().then((s) => {
|
|
28
|
+
if (stopped) return;
|
|
29
|
+
if (s !== state) {
|
|
30
|
+
state = s;
|
|
31
|
+
for (const l of listeners) l(state);
|
|
32
|
+
}
|
|
33
|
+
});
|
|
34
|
+
}, pollMs);
|
|
35
|
+
return {
|
|
36
|
+
getState() {
|
|
37
|
+
return state;
|
|
38
|
+
},
|
|
39
|
+
subscribe(handler) {
|
|
40
|
+
listeners.add(handler);
|
|
41
|
+
return () => {
|
|
42
|
+
listeners.delete(handler);
|
|
43
|
+
};
|
|
44
|
+
},
|
|
45
|
+
async stop() {
|
|
46
|
+
stopped = true;
|
|
47
|
+
if (interval !== null) {
|
|
48
|
+
clearInterval(interval);
|
|
49
|
+
interval = null;
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
};
|
|
53
|
+
};
|
|
54
|
+
//#endregion
|
|
55
|
+
export { createWindowsSessionProvider };
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@sirenodeck/sirenodeck",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.6",
|
|
4
4
|
"description": "CLI for managing Elgato Stream Deck devices via a config-driven deck system.",
|
|
5
5
|
"homepage": "https://deck.sireno.dev",
|
|
6
6
|
"bugs": {
|
|
@@ -18,7 +18,7 @@
|
|
|
18
18
|
"files": [
|
|
19
19
|
"bin",
|
|
20
20
|
"config",
|
|
21
|
-
"dist
|
|
21
|
+
"dist",
|
|
22
22
|
"src",
|
|
23
23
|
"LICENSE",
|
|
24
24
|
"README.md",
|