Repository navigation
Expand file tree
/
Copy pathtool-provider.ts
More file actions
106 lines (97 loc) · 3.58 KB
/
Copy pathtool-provider.ts
File metadata and controls
106 lines (97 loc) · 3.58 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import path from 'node:path';
import type { VegaTvRemoteKey } from '@agent-device/contracts/tv-remote';
import {
isExecutablePath,
runCmd,
whichCmd,
type ExecOptions,
type ExecResult,
commandHostEnvironment,
} from '@agent-device/host-kit/command';
import { hostHomeDirectory } from '@agent-device/host-kit/host-file';
import { createScopedProvider } from '@agent-device/kernel/scoped-provider';
export type VegaToolProvider = {
isAvailable(): Promise<boolean>;
version(options?: ExecOptions): Promise<ExecResult>;
listDevices(options?: ExecOptions): Promise<ExecResult>;
checkConnected(deviceId: string, options?: ExecOptions): Promise<ExecResult>;
launchApp(deviceId: string, appName: string, options?: ExecOptions): Promise<ExecResult>;
terminateApp(deviceId: string, appName: string, options?: ExecOptions): Promise<ExecResult>;
pressRemote(
deviceId: string,
key: VegaTvRemoteKey,
durationMs?: number,
options?: ExecOptions,
): Promise<ExecResult>;
};
export type VegaCliAdapter = {
run(args: string[], options?: ExecOptions): Promise<ExecResult>;
isAvailable(): Promise<boolean>;
};
const localVegaCliAdapter: VegaCliAdapter = {
run: async (args, options) =>
await runCmd((await resolveVegaCliExecutable()) ?? 'vega', args, options),
isAvailable: async () => Boolean(await resolveVegaCliExecutable()),
};
const localVegaToolProvider = createLocalVegaToolProvider();
const vegaToolProviderScope = createScopedProvider(localVegaToolProvider);
export function createLocalVegaToolProvider(
adapter: VegaCliAdapter = localVegaCliAdapter,
): VegaToolProvider {
return {
isAvailable: async () => await adapter.isAvailable(),
version: async (options) => await adapter.run(['--version'], options),
listDevices: async (options) => await adapter.run(['device', 'list'], options),
checkConnected: async (deviceId, options) =>
await adapter.run(['device', 'is-connected', '--device', deviceId], options),
launchApp: async (deviceId, appName, options) =>
await adapter.run(
['device', 'launch-app', '--device', deviceId, '--appName', appName],
options,
),
terminateApp: async (deviceId, appName, options) =>
await adapter.run(
['device', 'terminate-app', '--device', deviceId, '--appName', appName],
options,
),
pressRemote: async (deviceId, key, durationMs, options) =>
await adapter.run(
[
'device',
'run-cmd',
'--device',
deviceId,
'--command',
[
'inputd-cli',
'button_press',
key,
...(durationMs !== undefined ? ['--holdDuration', String(durationMs)] : []),
].join(' '),
],
options,
),
};
}
export function resolveVegaToolProvider(provider?: VegaToolProvider): VegaToolProvider {
return vegaToolProviderScope.resolve(provider);
}
export async function withVegaToolProvider<T>(
provider: VegaToolProvider | undefined,
fn: () => Promise<T>,
): Promise<T> {
return await vegaToolProviderScope.run(provider, fn);
}
let cachedVegaCliExecutable: string | undefined;
async function resolveVegaCliExecutable(): Promise<string | undefined> {
if (cachedVegaCliExecutable) return cachedVegaCliExecutable;
if (await whichCmd('vega', commandHostEnvironment().env)) {
cachedVegaCliExecutable = 'vega';
return cachedVegaCliExecutable;
}
const defaultInstall = path.join(hostHomeDirectory(), 'vega', 'bin', 'vega');
if (await isExecutablePath(defaultInstall)) {
cachedVegaCliExecutable = defaultInstall;
}
return cachedVegaCliExecutable;
}