orca-multiagent-kit 1.4.1 → 1.5.0
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/CHANGELOG.md +16 -1
- package/README.md +12 -7
- package/VERSION +1 -1
- package/bin/omk.js +40 -4
- package/bin/orca.js +170 -0
- package/bin/sea.js +95 -0
- package/bin/setup.js +326 -0
- package/core/AGENTS.md +1 -1
- package/docs/EJECUTABLE.md +70 -0
- package/docs/PLUGIN-ORCA.md +24 -15
- package/orca-plugin/orca-plugin.json +5 -2
- package/orca-plugin/src/kit.ts +23 -5
- package/orca-plugin/src/panel.test.tsx +100 -0
- package/orca-plugin/src/panel.tsx +205 -0
- package/orca-plugin/src/protocol.ts +18 -0
- package/orca-plugin/src/worker.test.ts +39 -0
- package/orca-plugin/src/worker.ts +43 -6
- package/package.json +3 -2
package/bin/setup.js
ADDED
|
@@ -0,0 +1,326 @@
|
|
|
1
|
+
// omk setup y omk plugin: deja Orca listo para el kit (kit instalado, plugins encendidos, plugin del
|
|
2
|
+
// kit instalado y su panel abierto) y, en el ejecutable autónomo, pone omk en el PATH.
|
|
3
|
+
'use strict';
|
|
4
|
+
|
|
5
|
+
const { spawnSync } = require('node:child_process');
|
|
6
|
+
const fs = require('node:fs');
|
|
7
|
+
const os = require('node:os');
|
|
8
|
+
const path = require('node:path');
|
|
9
|
+
const readline = require('node:readline');
|
|
10
|
+
const orcaCli = require('./orca');
|
|
11
|
+
const { c, sym } = require('./ui');
|
|
12
|
+
|
|
13
|
+
const out = (s = '') => process.stdout.write(s + '\n');
|
|
14
|
+
const ok = (s) => out(` ${sym.ok} ${s}`);
|
|
15
|
+
const warn = (s) => out(` ${sym.warn} ${s}`);
|
|
16
|
+
const fail = (s) => out(` ${sym.fail} ${c.red(s)}`);
|
|
17
|
+
const todo = (s) => out(` ${sym.todo} ${s}`);
|
|
18
|
+
const detail = (s) => out(` ${sym.info} ${c.grey(s)}`);
|
|
19
|
+
const heading = (s) => { out(); out(` ${c.lime('◆')} ${c.bold(s)}`); };
|
|
20
|
+
|
|
21
|
+
/** Separa las opciones propias de omk setup/plugin de las que van a install.sh. */
|
|
22
|
+
function parseOptions(args) {
|
|
23
|
+
const own = { yes: false, dryRun: false, noPlugin: false, noPath: false };
|
|
24
|
+
const rest = [];
|
|
25
|
+
for (const a of args) {
|
|
26
|
+
if (a === '--yes' || a === '-y') own.yes = true;
|
|
27
|
+
else if (a === '--no-plugin') own.noPlugin = true;
|
|
28
|
+
else if (a === '--no-path') own.noPath = true;
|
|
29
|
+
else { if (a === '--dry-run') own.dryRun = true; rest.push(a); }
|
|
30
|
+
}
|
|
31
|
+
return { ...own, rest };
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
async function ask(question) {
|
|
35
|
+
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
|
|
36
|
+
try {
|
|
37
|
+
const answer = await new Promise((resolve) => rl.question(question, resolve));
|
|
38
|
+
return /^(s|si|sí|y|yes)$/i.test(String(answer).trim());
|
|
39
|
+
} finally {
|
|
40
|
+
rl.close();
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
// Orca exige una aprobación explícita del usuario para un plugin que ejecuta código: se enseña lo que
|
|
45
|
+
// concede y se pregunta. --yes es esa aprobación dada de antemano.
|
|
46
|
+
const confirmWith = (yes) => async (grants, data) => {
|
|
47
|
+
out();
|
|
48
|
+
out(` ${c.amber(c.bold('Orca pide tu aprobación'))} ${c.grey(orcaCli.clean(`para ${data.name || 'el plugin'} ${data.version || ''}`))}`);
|
|
49
|
+
for (const g of grants) detail(g);
|
|
50
|
+
if (yes) { ok('Aprobado (--yes)'); return true; }
|
|
51
|
+
if (!process.stdin.isTTY) {
|
|
52
|
+
warn('Sin terminal interactivo no puedo preguntarte. Repite con --yes para aprobarlo.');
|
|
53
|
+
return false;
|
|
54
|
+
}
|
|
55
|
+
return ask(` ${sym.todo} ¿Apruebas este acceso? [s/N] `);
|
|
56
|
+
};
|
|
57
|
+
|
|
58
|
+
function listPlugin(orca) {
|
|
59
|
+
const list = orcaCli.runOrca(orca, ['plugin', 'list']);
|
|
60
|
+
if (list.code !== 0) throw new Error(`no pude listar los plugins de Orca (${list.problem})`);
|
|
61
|
+
return orcaCli.findInstalled(list.json);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
const PLAN_ARGS = {
|
|
65
|
+
install: (dir) => ['plugin', 'install', dir],
|
|
66
|
+
update: (dir, installed) => ['plugin', 'update', installed.pluginKey],
|
|
67
|
+
enable: (dir, installed) => ['plugin', 'enable', installed.pluginKey],
|
|
68
|
+
};
|
|
69
|
+
|
|
70
|
+
const PLAN_TEXT = {
|
|
71
|
+
install: 'instalaría el plugin',
|
|
72
|
+
update: 'actualizaría el plugin',
|
|
73
|
+
enable: 'pediría la aprobación del plugin',
|
|
74
|
+
current: 'el plugin ya está instalado y activo',
|
|
75
|
+
disabled: 'el plugin está desactivado y se deja así',
|
|
76
|
+
foreign: 'hay otra versión del plugin instalada desde otra carpeta y no se toca',
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
/** Instala, actualiza o aprueba el plugin del kit. Devuelve su clave, o null si no quedó instalado. */
|
|
80
|
+
async function ensurePlugin(orca, kit, { yes, dryRun }) {
|
|
81
|
+
const dir = path.join(kit, 'orca-plugin');
|
|
82
|
+
const { version } = orcaCli.readManifest(dir);
|
|
83
|
+
const installed = listPlugin(orca);
|
|
84
|
+
const plan = orcaCli.planPlugin(installed, dir, version);
|
|
85
|
+
if (dryRun) { detail(`Simulación: ${PLAN_TEXT[plan]} (v${version}).`); return null; }
|
|
86
|
+
|
|
87
|
+
if (plan === 'disabled') {
|
|
88
|
+
warn(`Plugin ${installed.pluginKey} v${version} desactivado: lo respeto.`);
|
|
89
|
+
todo(`Para activarlo: orca plugin enable ${installed.pluginKey}`);
|
|
90
|
+
return installed.pluginKey;
|
|
91
|
+
}
|
|
92
|
+
if (plan === 'foreign') {
|
|
93
|
+
warn(`Ya hay ${installed.pluginKey} v${installed.version} instalado desde otra carpeta; este kit trae la v${version}.`);
|
|
94
|
+
todo('Para cambiarlo por el de este kit: omk plugin uninstall && omk plugin install');
|
|
95
|
+
return installed.pluginKey;
|
|
96
|
+
}
|
|
97
|
+
if (plan !== 'current') {
|
|
98
|
+
const result = await orcaCli.withApproval(orca, PLAN_ARGS[plan](dir, installed), confirmWith(yes));
|
|
99
|
+
if (result.declined) { fail('Plugin sin instalar: no se aprobó el acceso.'); return null; }
|
|
100
|
+
if (result.code !== 0) { fail(`Orca no instaló el plugin: ${result.problem}`); return null; }
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
const now = listPlugin(orca);
|
|
104
|
+
if (!now || now.version !== version) { fail(`Orca no lista el plugin v${version} después de instalarlo.`); return null; }
|
|
105
|
+
if (now.status === 'errored' || now.status === 'invalid') {
|
|
106
|
+
warn(`Plugin ${now.pluginKey} v${version} instalado, pero Orca lo marca como ${now.status}.`);
|
|
107
|
+
todo(`Detalle: orca plugin logs ${now.pluginKey}`);
|
|
108
|
+
return now.pluginKey;
|
|
109
|
+
}
|
|
110
|
+
ok(`Plugin ${now.pluginKey} v${version} ${plan === 'current' ? 'ya estaba instalado' : 'instalado'} ${c.grey('(' + now.status + ')')}`);
|
|
111
|
+
return now.pluginKey;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
function requireOrca(manifestDir) {
|
|
115
|
+
const orca = orcaCli.findOrca();
|
|
116
|
+
if (!orca) {
|
|
117
|
+
fail(process.env.OMK_ORCA ? `OMK_ORCA=${process.env.OMK_ORCA} no responde a «orca --version».` : 'No encuentro el CLI de Orca.');
|
|
118
|
+
todo('Instala Orca (https://www.onorca.dev), ábrelo una vez y vuelve a ejecutar esto. Si ya lo tienes, define OMK_ORCA con la ruta de su CLI.');
|
|
119
|
+
return null;
|
|
120
|
+
}
|
|
121
|
+
const need = (orcaCli.readManifest(manifestDir).engines || {}).orca;
|
|
122
|
+
if (!orcaCli.satisfies(orca.version, need)) {
|
|
123
|
+
fail(`Orca ${orca.version}: el plugin necesita ${need}. Actualiza Orca y repite.`);
|
|
124
|
+
return null;
|
|
125
|
+
}
|
|
126
|
+
ok(`Orca ${orca.version} ${c.grey(orca.path)}`);
|
|
127
|
+
return orca;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
function ensureRuntime(orca) {
|
|
131
|
+
const status = orcaCli.runOrca(orca, ['status']);
|
|
132
|
+
const runtime = status.json && status.json.result && status.json.result.runtime;
|
|
133
|
+
if (runtime && runtime.reachable) return true;
|
|
134
|
+
detail('Orca no está abierto: lo abro y espero a que arranque…');
|
|
135
|
+
const opened = orcaCli.runOrca(orca, ['open'], orcaCli.OPEN_TIMEOUT_MS);
|
|
136
|
+
if (opened.code === 0) { ok('Orca abierto'); return true; }
|
|
137
|
+
fail(`No pude abrir Orca: ${opened.problem}`);
|
|
138
|
+
return false;
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
// --------------------------------------------------------------------- ejecutable en el PATH
|
|
142
|
+
|
|
143
|
+
/** Carpeta donde el ejecutable autónomo se copia a sí mismo. */
|
|
144
|
+
function binDir(env = process.env, platform = process.platform, home = os.homedir()) {
|
|
145
|
+
if (env.OMK_BIN_DIR) return path.resolve(env.OMK_BIN_DIR);
|
|
146
|
+
if (platform === 'win32') return path.join(env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'Programs', 'orca-multiagent-kit');
|
|
147
|
+
return path.join(home, '.local', 'bin');
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
const SEA_FUSE = 'NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2';
|
|
151
|
+
|
|
152
|
+
// Solo se reemplaza un `omk` que sea este mismo ejecutable (otra versión): nunca otra herramienta con ese nombre.
|
|
153
|
+
function isKitExecutable(file) {
|
|
154
|
+
try {
|
|
155
|
+
const st = fs.lstatSync(file);
|
|
156
|
+
if (!st.isFile()) return false;
|
|
157
|
+
const bytes = fs.readFileSync(file);
|
|
158
|
+
return bytes.includes(SEA_FUSE) && bytes.includes('orca-multiagent-kit');
|
|
159
|
+
} catch {
|
|
160
|
+
return false;
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
const onPath = (dir, envPath = process.env.PATH || '') =>
|
|
165
|
+
envPath.split(path.delimiter).filter(Boolean).some((p) => orcaCli.samePath(p, dir));
|
|
166
|
+
|
|
167
|
+
// Añade la carpeta al Path del usuario (HKCU\Environment) conservando su tipo (REG_EXPAND_SZ) y las
|
|
168
|
+
// variables sin expandir, y avisa a Windows del cambio. La ruta llega por OMK_BIN_DIR, nunca en el script.
|
|
169
|
+
const WIN_ADD_TO_PATH = `
|
|
170
|
+
$ErrorActionPreference = 'Stop'
|
|
171
|
+
$dir = $env:OMK_BIN_DIR
|
|
172
|
+
$key = [Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment', $true)
|
|
173
|
+
try {
|
|
174
|
+
$current = $key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
|
|
175
|
+
$parts = @($current -split ';' | Where-Object { $_ })
|
|
176
|
+
if ($parts -contains $dir) { 'present'; exit 0 }
|
|
177
|
+
$kind = if ($current) { $key.GetValueKind('Path') } else { [Microsoft.Win32.RegistryValueKind]::ExpandString }
|
|
178
|
+
$key.SetValue('Path', (($parts + $dir) -join ';'), $kind)
|
|
179
|
+
} finally { $key.Close() }
|
|
180
|
+
Add-Type -Namespace OmkWin -Name Env -MemberDefinition '[DllImport("user32.dll", CharSet = CharSet.Unicode)] public static extern System.IntPtr SendMessageTimeout(System.IntPtr hWnd, uint msg, System.UIntPtr wParam, string lParam, uint flags, uint timeout, out System.UIntPtr result);'
|
|
181
|
+
$ignored = [UIntPtr]::Zero
|
|
182
|
+
[void][OmkWin.Env]::SendMessageTimeout([IntPtr]0xffff, 0x1A, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$ignored)
|
|
183
|
+
'added'
|
|
184
|
+
`;
|
|
185
|
+
|
|
186
|
+
function addToWindowsPath(dir) {
|
|
187
|
+
const r = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', WIN_ADD_TO_PATH], {
|
|
188
|
+
encoding: 'utf8', env: { ...process.env, OMK_BIN_DIR: dir }, timeout: 60000, windowsHide: true,
|
|
189
|
+
});
|
|
190
|
+
if (r.error || r.status !== 0) throw new Error(`no pude añadir ${dir} al PATH del usuario: ${(r.stderr || (r.error && r.error.message) || '').trim()}`);
|
|
191
|
+
return r.stdout.trim();
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
/** Copia el ejecutable autónomo a binDir() y se asegura de que esa carpeta está en el PATH. */
|
|
195
|
+
function installSelf({ noPath }) {
|
|
196
|
+
const dir = binDir();
|
|
197
|
+
const target = path.join(dir, process.platform === 'win32' ? 'omk.exe' : 'omk');
|
|
198
|
+
heading('omk en el PATH');
|
|
199
|
+
if (!orcaCli.samePath(process.execPath, target)) {
|
|
200
|
+
if (fs.existsSync(target) && !isKitExecutable(target)) {
|
|
201
|
+
warn(`${target} existe y no es el ejecutable del kit: no lo toco.`);
|
|
202
|
+
todo('Define OMK_BIN_DIR con otra carpeta y repite, o borra ese fichero si es una copia vieja.');
|
|
203
|
+
return false;
|
|
204
|
+
}
|
|
205
|
+
fs.mkdirSync(dir, { recursive: true });
|
|
206
|
+
const tmp = `${target}.new`;
|
|
207
|
+
fs.copyFileSync(process.execPath, tmp);
|
|
208
|
+
fs.chmodSync(tmp, 0o755);
|
|
209
|
+
fs.renameSync(tmp, target);
|
|
210
|
+
ok(`omk copiado en ${target}`);
|
|
211
|
+
} else {
|
|
212
|
+
ok(`omk ya está en ${target}`);
|
|
213
|
+
}
|
|
214
|
+
if (onPath(dir)) { ok('Su carpeta ya está en el PATH'); return true; }
|
|
215
|
+
if (noPath) { todo(`Añade ${dir} al PATH para usar omk en cualquier terminal.`); return true; }
|
|
216
|
+
if (process.platform === 'win32') {
|
|
217
|
+
const result = addToWindowsPath(dir);
|
|
218
|
+
ok(result === 'present' ? 'Su carpeta ya estaba en el PATH del usuario' : `${dir} añadido al PATH del usuario`);
|
|
219
|
+
todo('Cierra y vuelve a abrir Orca (y los terminales abiertos) para que vean omk.');
|
|
220
|
+
} else {
|
|
221
|
+
todo(`Añade ${dir} al PATH: echo 'export PATH="${dir}:$PATH"' >> ~/.zshrc (o ~/.bashrc)`);
|
|
222
|
+
}
|
|
223
|
+
return true;
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
// --------------------------------------------------------------------------------- comandos
|
|
227
|
+
|
|
228
|
+
/**
|
|
229
|
+
* omk setup: kit global, Orca abierto, plugins encendidos, plugin del kit instalado y su panel
|
|
230
|
+
* abierto. Devuelve el código de salida.
|
|
231
|
+
*/
|
|
232
|
+
async function setup({ kit, args, installer, standalone }) {
|
|
233
|
+
const opts = parseOptions(args);
|
|
234
|
+
const code = await installer(opts.rest);
|
|
235
|
+
if (code !== 0) return code;
|
|
236
|
+
if (standalone && opts.dryRun) {
|
|
237
|
+
heading('omk en el PATH');
|
|
238
|
+
detail(`Simulación: copiaría omk a ${binDir()} y comprobaría que está en el PATH.`);
|
|
239
|
+
} else if (standalone) {
|
|
240
|
+
try {
|
|
241
|
+
if (!installSelf(opts)) return 1;
|
|
242
|
+
} catch (e) {
|
|
243
|
+
fail(e.message);
|
|
244
|
+
return 1;
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
if (opts.noPlugin) return 0;
|
|
248
|
+
|
|
249
|
+
heading('Orca');
|
|
250
|
+
const orca = requireOrca(path.join(kit, 'orca-plugin'));
|
|
251
|
+
if (!orca) return 1;
|
|
252
|
+
if (opts.dryRun) {
|
|
253
|
+
detail('Simulación: abriría Orca si no está abierto y encendería los plugins.');
|
|
254
|
+
await ensurePlugin(orca, kit, opts);
|
|
255
|
+
out();
|
|
256
|
+
return 0;
|
|
257
|
+
}
|
|
258
|
+
if (!ensureRuntime(orca)) return 1;
|
|
259
|
+
const on = orcaCli.runOrca(orca, ['plugin', 'system', 'on']);
|
|
260
|
+
if (on.code !== 0) { fail(`No pude encender los plugins de Orca: ${on.problem}`); return 1; }
|
|
261
|
+
ok('Plugins de Orca encendidos');
|
|
262
|
+
|
|
263
|
+
const key = await ensurePlugin(orca, kit, opts);
|
|
264
|
+
if (!key) return 1;
|
|
265
|
+
const shown = orcaCli.runOrca(orca, ['plugin', 'open', key, '--panel', orcaCli.PANEL_ID]);
|
|
266
|
+
if (shown.code === 0) ok('Panel «Multiagent Kit» abierto en la barra lateral derecha de Orca');
|
|
267
|
+
else warn(`No pude abrir el panel (${shown.problem}). Está en la barra lateral derecha de Orca.`);
|
|
268
|
+
|
|
269
|
+
out();
|
|
270
|
+
out(` ${sym.ok} ${c.bold('Entorno de Orca listo')}`);
|
|
271
|
+
for (const [k, v] of [
|
|
272
|
+
['ajustes', 'panel «Multiagent Kit» o Settings → Plugins → Orca Multiagent Kit'],
|
|
273
|
+
['paleta', '«Orca Multiagent Kit: …» (verificar, inicializar, actualizar)'],
|
|
274
|
+
['proyecto', 'en el agente: «inicializa el proyecto»'],
|
|
275
|
+
]) out(` ${c.grey(k.padEnd(10))} ${c.lime(v)}`);
|
|
276
|
+
out();
|
|
277
|
+
return 0;
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
/** omk plugin <install|status|uninstall>. Devuelve el código de salida. */
|
|
281
|
+
async function plugin({ kit, args }) {
|
|
282
|
+
const [sub = 'status', ...rest] = args;
|
|
283
|
+
if (!['install', 'status', 'uninstall'].includes(sub)) {
|
|
284
|
+
fail(`subcomando desconocido: ${sub} (install, status, uninstall)`);
|
|
285
|
+
return 2;
|
|
286
|
+
}
|
|
287
|
+
const opts = parseOptions(rest);
|
|
288
|
+
heading(`Plugin de Orca · ${sub}`);
|
|
289
|
+
const orca = requireOrca(path.join(kit, 'orca-plugin'));
|
|
290
|
+
if (!orca) return 1;
|
|
291
|
+
const installed = listPlugin(orca);
|
|
292
|
+
const { version } = orcaCli.readManifest(path.join(kit, 'orca-plugin'));
|
|
293
|
+
|
|
294
|
+
switch (sub) {
|
|
295
|
+
case 'install': {
|
|
296
|
+
if (!opts.dryRun) {
|
|
297
|
+
const on = orcaCli.runOrca(orca, ['plugin', 'system', 'on']);
|
|
298
|
+
if (on.code !== 0) { fail(`No pude encender los plugins de Orca: ${on.problem}`); return 1; }
|
|
299
|
+
}
|
|
300
|
+
const key = await ensurePlugin(orca, kit, opts);
|
|
301
|
+
return key || opts.dryRun ? 0 : 1;
|
|
302
|
+
}
|
|
303
|
+
case 'status':
|
|
304
|
+
if (!installed) { warn(`No instalado. Este kit trae la v${version}: omk plugin install`); return 1; }
|
|
305
|
+
ok(`${installed.pluginKey} v${installed.version} ${c.grey('(' + installed.status + ')')}`);
|
|
306
|
+
if (installed.version !== version) todo(`Este kit trae la v${version}: omk plugin install`);
|
|
307
|
+
return 0;
|
|
308
|
+
case 'uninstall': {
|
|
309
|
+
if (!installed) { ok('No estaba instalado'); return 0; }
|
|
310
|
+
const r = orcaCli.runOrca(orca, ['plugin', 'uninstall', installed.pluginKey]);
|
|
311
|
+
if (r.code !== 0) { fail(`Orca no lo desinstaló: ${r.problem}`); return 1; }
|
|
312
|
+
ok(`${installed.pluginKey} desinstalado`);
|
|
313
|
+
return 0;
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
/** Con el ejecutable abierto con doble clic, espera a Enter para que la ventana no se cierre sola. */
|
|
319
|
+
async function pauseIfAsked(code) {
|
|
320
|
+
if (process.env.OMK_PAUSE === '1' && process.stdin.isTTY) {
|
|
321
|
+
await ask(`\n ${c.grey('Pulsa Enter para cerrar')} `);
|
|
322
|
+
}
|
|
323
|
+
return code;
|
|
324
|
+
}
|
|
325
|
+
|
|
326
|
+
module.exports = { setup, plugin, pauseIfAsked, parseOptions, binDir };
|
package/core/AGENTS.md
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
# Reglas operativas globales (Orca Multiagent Kit v1.
|
|
1
|
+
# Reglas operativas globales (Orca Multiagent Kit v1.5.0 · CSR + MAW)
|
|
2
2
|
<!-- Fuente única para todos los agentes (import o enlace). Edita el kit y reinstala; no edites copias. -->
|
|
3
3
|
|
|
4
4
|
## 0. Precedencia
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
# Ejecutable y `omk setup`: Orca listo de una vez
|
|
2
|
+
|
|
3
|
+
`omk setup` deja [Orca](https://www.onorca.dev) preparado para el kit con una sola orden. El ejecutable autónomo (`omk-windows-x64.exe`, `omk-macos-arm64`, `omk-linux-x64`) es lo mismo para quien no tiene Node: se descarga, se abre y hace `omk setup`.
|
|
4
|
+
|
|
5
|
+
## Qué hace `omk setup`
|
|
6
|
+
|
|
7
|
+
| Paso | Qué pasa | Si falla |
|
|
8
|
+
|---|---|---|
|
|
9
|
+
| 1. Kit | `omk install` (con backup, como siempre; acepta `--agents` y `--dry-run`) | Se para con el código de `install.sh` |
|
|
10
|
+
| 2. `omk` en el `PATH` (solo el ejecutable) | Se copia a sí mismo a `%LOCALAPPDATA%\Programs\orca-multiagent-kit\omk.exe` (Windows) o `~/.local/bin/omk`, y en Windows añade esa carpeta al `Path` de tu usuario | No pisa un `omk` que no sea el del kit; lo dice y sale con error |
|
|
11
|
+
| 3. Orca | Busca su CLI (`PATH`, o donde lo deja el instalador de Orca; `OMK_ORCA` para indicar otro) y comprueba que su versión cumple `engines.orca` del plugin | Dice qué falta (instalar o actualizar Orca) y sale con error |
|
|
12
|
+
| 4. App | Si Orca no está abierto, `orca open` y espera a que arranque | Sale con error |
|
|
13
|
+
| 5. Plugins | `orca plugin system on` (el mismo interruptor que *Settings → Plugins → Turn on plugins*; no aprueba nada) | Sale con error |
|
|
14
|
+
| 6. Plugin del kit | Instala, actualiza o aprueba el plugin, según lo que haya ([detalle](PLUGIN-ORCA.md#instalar)). Orca enseña lo que concede y **omk te pregunta** antes de aprobarlo | Sin tu sí no se instala, y sale con error |
|
|
15
|
+
| 7. Panel | `orca plugin open local.multiagent-kit --panel kit`: el panel *Multiagent Kit* queda abierto en la barra lateral derecha | Solo avisa |
|
|
16
|
+
|
|
17
|
+
```bash
|
|
18
|
+
omk setup --dry-run # qué haría, sin escribir ni instalar nada
|
|
19
|
+
omk setup # pregunta antes de aprobar el plugin
|
|
20
|
+
omk setup --yes # aprueba el acceso del plugin sin preguntar (lo que liste Orca)
|
|
21
|
+
omk setup --no-plugin # solo el kit (y omk en el PATH, con el ejecutable)
|
|
22
|
+
omk setup --no-path # el ejecutable no toca el PATH; te dice qué añadir
|
|
23
|
+
```
|
|
24
|
+
|
|
25
|
+
Con doble clic, el ejecutable hace `omk setup` y espera a que pulses Enter antes de cerrar la ventana.
|
|
26
|
+
|
|
27
|
+
**Ajustes del plugin**: en el panel *Multiagent Kit* o en *Settings → Plugins → Orca Multiagent Kit*, que Orca construye con los ajustes que declara el manifiesto. Son los mismos valores en los dos sitios.
|
|
28
|
+
|
|
29
|
+
## El ejecutable
|
|
30
|
+
|
|
31
|
+
Es un [Node SEA](https://nodejs.org/api/single-executable-applications.html): el Node oficial con el kit dentro. Al arrancar extrae el kit a una carpeta estable y ejecuta `omk` desde ella:
|
|
32
|
+
|
|
33
|
+
| Sistema | Kit extraído | `omk` |
|
|
34
|
+
|---|---|---|
|
|
35
|
+
| Windows | `%LOCALAPPDATA%\Programs\orca-multiagent-kit\kit` | `%LOCALAPPDATA%\Programs\orca-multiagent-kit\omk.exe` |
|
|
36
|
+
| macOS, Linux | `~/.local/share/orca-multiagent-kit` | `~/.local/bin/omk` |
|
|
37
|
+
|
|
38
|
+
`OMK_HOME` y `OMK_BIN_DIR` cambian esas carpetas. La carpeta del kit tiene que existir para que Orca pueda actualizar el plugin (`orca plugin update` vuelve a copiar la carpeta desde la que se instaló).
|
|
39
|
+
|
|
40
|
+
- Solo extrae cuando cambia la build (sello `.omk-build` con el SHA-256 del kit embebido). Extrae en `<carpeta>.new` y la cambia por la anterior al final: una extracción a medias no deja un kit roto.
|
|
41
|
+
- No pisa una carpeta que no sea una copia del kit (sin `VERSION` e `install.sh`). En macOS y Linux es la misma carpeta que usa `scripts/get.sh`: la versión que quede es la del último que se ejecutó.
|
|
42
|
+
- `omk update` en el ejecutable no descarga nada: te da el enlace de la última release y vuelve a aplicar la instalación de su versión.
|
|
43
|
+
- Sigue necesitando bash para `install.sh`: en Windows, Git for Windows (Orca usa Git para los worktrees, así que suele estar ya).
|
|
44
|
+
- Pesa ~90 MiB, porque lleva Node entero.
|
|
45
|
+
|
|
46
|
+
**PATH en Windows.** Escribe en `HKCU\Environment\Path` con la API del registro, sin expandir las variables que ya tenga (`%USERPROFILE%\…`) y conservando su tipo (`REG_EXPAND_SZ`), y avisa a Windows del cambio. Orca y los terminales abiertos antes no lo ven: **cierra y vuelve a abrir Orca** para que los comandos del plugin encuentren `omk`. En macOS y Linux no toca tus ficheros de shell: te dice la línea que tienes que añadir si `~/.local/bin` no está en el `PATH`.
|
|
47
|
+
|
|
48
|
+
**Firma.** Los binarios de la release no están firmados con un certificado de desarrollador. Windows SmartScreen puede avisar al abrirlo (*Más información → Ejecutar de todas formas*), y en macOS lleva solo firma ad hoc: si Gatekeeper lo bloquea, `xattr -d com.apple.quarantine omk-macos-arm64`. Comprueba la integridad con su `.sha256` antes de abrirlo.
|
|
49
|
+
|
|
50
|
+
## Construirlo
|
|
51
|
+
|
|
52
|
+
```bash
|
|
53
|
+
node scripts/build-exe.js # o: npm run build:exe
|
|
54
|
+
bash tests/test_exe.sh # pruebas del ejecutable, en carpetas desechables y con un doble de Orca
|
|
55
|
+
```
|
|
56
|
+
|
|
57
|
+
Construye el ejecutable del sistema y la arquitectura donde se ejecuta, con el Node que lo ejecuta (≥ 20.12; la CI usa 22). Deja `dist/omk-<sistema>-<arquitectura>[.exe]` y su `.sha256`. Node SEA no compila para otro sistema: la release construye cada uno en su runner (`.github/workflows/release.yml`, job `exe`).
|
|
58
|
+
|
|
59
|
+
Pasos: empaqueta en `kit.json.gz` lo mismo que el zip de la release; genera el blob con `node --experimental-sea-config`; copia el binario de Node; inyecta el blob con [`postject`](https://github.com/nodejs/postject) (de nodejs, fijado a `1.0.0-alpha.6`, se descarga con `npx` al construir y no va dentro del ejecutable); en macOS quita la firma de Node antes y firma ad hoc después.
|
|
60
|
+
|
|
61
|
+
## Pruebas
|
|
62
|
+
|
|
63
|
+
- `tests/test_orca.sh`: `omk setup` y `omk plugin` contra `tests/fixtures/fake-orca.js`, un doble del CLI de Orca (`OMK_ORCA` apunta siempre a él: las pruebas nunca hablan con tu Orca). Cubre la aprobación (sin `--yes` ni terminal no aprueba; con `--yes` usa la huella de Orca; una huella con formato inesperado se rechaza), cada estado del plugin, Orca ausente o antigua, y `setup` completo, en simulación y sin aprobación.
|
|
64
|
+
- `tests/test_exe.sh`: el ejecutable (extracción, sello, carpeta ajena, `install --dry-run`, `update`, `setup` copiándose a `OMK_BIN_DIR` sin tocar el `PATH`, un `omk` ajeno que no se pisa).
|
|
65
|
+
- La CI ejecuta las dos en Linux, macOS y Windows (job `exe`).
|
|
66
|
+
|
|
67
|
+
DEFERRED:
|
|
68
|
+
- **Autoactualización del ejecutable**: `omk update` en el ejecutable da el enlace a la release, no descarga. Descargar y sustituir un binario en ejecución exige verificar su integridad (firma o checksum publicado) y en Windows renombrarlo en caliente; queda para otro PR.
|
|
69
|
+
- **Firma de código** (Authenticode, notarización de Apple): necesita certificados del proyecto.
|
|
70
|
+
- **Linux arm64 y macOS x64**: la release construye los runners por defecto de GitHub (`ubuntu-latest` x64, `macos-latest` arm64, `windows-latest` x64).
|
package/docs/PLUGIN-ORCA.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# Plugin de Orca
|
|
2
2
|
|
|
3
|
-
El kit funciona en [Orca](https://www.onorca.dev) sin plugin: las skills viven en `~/.agents/skills` (el mismo sitio donde Orca instala las suyas) y la skill `orca` usa `orca orchestration` como motor. El plugin `orca-plugin/` añade lo que solo puede hacer la propia app: comandos en la paleta, un cambio en los despachos de orquestación y un indicador en la barra de estado.
|
|
3
|
+
El kit funciona en [Orca](https://www.onorca.dev) sin plugin: las skills viven en `~/.agents/skills` (el mismo sitio donde Orca instala las suyas) y la skill `orca` usa `orca orchestration` como motor. El plugin `orca-plugin/` añade lo que solo puede hacer la propia app: comandos en la paleta, un panel lateral con acciones y ajustes, un cambio en los despachos de orquestación y un indicador en la barra de estado.
|
|
4
4
|
|
|
5
5
|
Requisitos: Orca ≥ 1.4.248 (hooks y barra de estado) con los plugins activados (*Settings → Plugins → Turn on plugins*). Para los comandos, el kit instalado (`omk` en el `PATH`).
|
|
6
6
|
|
|
@@ -12,10 +12,11 @@ Requisitos: Orca ≥ 1.4.248 (hooks y barra de estado) con los plugins activados
|
|
|
12
12
|
| **Orca Multiagent Kit: actualizar kit** | Lo mismo con `omk update` | `terminal.create` con el literal `omk update` |
|
|
13
13
|
| **Orca Multiagent Kit: inicializar proyecto** | Un agente nuevo en el workspace activo con el prompt «inicializa el proyecto» (skill `kit-init`) | `agent.launch`; el agente sale del ajuste *Agente para inicializar* (por defecto `claude`) |
|
|
14
14
|
| **Orca Multiagent Kit: estado de los agentes** | Una línea por agente activo: título y estado | Lo que ha ido contando la barra de estado |
|
|
15
|
+
| **Panel *Multiagent Kit*** (barra lateral derecha, icono de robot) | Botones de verificar, inicializar y actualizar; los tres ajustes del plugin; los agentes activos | Panel de componentes (`src/panel.tsx`) que pide las acciones al worker (`kit.run`, solo esas tres) y lee y escribe los ajustes con `settings` |
|
|
15
16
|
| **Contrato del worker** | Cada despacho de la skill `orca` lleva al final una línea que remite a `~/.agents/skills/orca/references/worker-contract.md` | Hook `agent.prompt.before` |
|
|
16
17
|
| **Barra de estado** `MAW · 2 trabajando · 1 bloqueado` | Agentes trabajando, bloqueados o esperando en todos los workspaces. Ámbar si hay alguno bloqueado. Al pulsarlo, el estado de los agentes | Evento `agent.status.changed` y `agents.list` al arrancar |
|
|
17
18
|
|
|
18
|
-
Si `omk` no está en el `PATH`, el terminal muestra el error del shell y, en unos 15 s, llega una notificación con cómo instalarlo (`npm install -g orca-multiagent-kit` o
|
|
19
|
+
Si `omk` no está en el `PATH`, el terminal muestra el error del shell y, en unos 15 s, llega una notificación con cómo instalarlo (`npm install -g orca-multiagent-kit` o el ejecutable de la release, que se deja a sí mismo en el `PATH`). Si el plugin no identifica el workspace activo (ninguno enfocado, o dos con el mismo nombre y rama), avisa y no ejecuta nada: es preferible no lanzar nada a lanzarlo en otro workspace.
|
|
19
20
|
|
|
20
21
|
### Por qué el contrato del worker
|
|
21
22
|
|
|
@@ -38,25 +39,34 @@ Es un plugin `trusted-worker`: Orca ejecuta `src/worker.ts` en un proceso Node a
|
|
|
38
39
|
| `agent:launch` | Lanzar el agente de «inicializar proyecto» (`agent.launch`) | No hay comando de inicializar |
|
|
39
40
|
| `agent:read` | Contar agentes por estado para la barra (`agents.list`, `agent.status.changed`) | La barra se queda en `MAW` |
|
|
40
41
|
| `notifications:show` | Avisos accionables (sin `omk`, sin workspace, fallos de Orca) | Los avisos solo quedan en `orca plugin logs` |
|
|
41
|
-
| `settings:own` | Leer los tres ajustes del plugin | Se usan los valores por defecto |
|
|
42
|
+
| `settings:own` | Leer los tres ajustes del plugin, y cambiarlos desde el panel | Se usan los valores por defecto y el panel no puede guardarlos |
|
|
42
43
|
|
|
43
44
|
Lo que **no** hace: no envía al terminal texto que venga de un usuario, de un agente o de un fichero (los dos comandos son literales fijos). El id de agente del ajuste se valida (`^[a-z0-9][a-z0-9-]{0,39}$`) antes de pasarlo a `agent.launch`. No usa red, secretos ni almacenamiento, no lee ficheros del proyecto y no importa módulos de Node (`fs`, `child_process`…): todo pasa por la API de Orca y sus capacidades.
|
|
44
45
|
|
|
45
46
|
## Instalar
|
|
46
47
|
|
|
47
|
-
El manifiesto está en `orca-plugin/`, no en la raíz del repo, así que se instala desde una carpeta (ver *Limitaciones*). Elige la que tengas:
|
|
48
|
-
|
|
49
48
|
```bash
|
|
50
|
-
#
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
# Con el kit instalado por npm (npm i -g orca-multiagent-kit)
|
|
54
|
-
orca plugin install "$(npm root -g)/orca-multiagent-kit/orca-plugin" --json
|
|
49
|
+
omk plugin install # enciende los plugins, enseña lo que pide el plugin y te pregunta antes de aprobarlo
|
|
50
|
+
omk plugin status # qué versión hay instalada y si es la de este kit
|
|
51
|
+
omk setup # todo el entorno: kit, Orca abierto, plugins encendidos, plugin y su panel
|
|
55
52
|
```
|
|
56
53
|
|
|
57
|
-
|
|
54
|
+
`omk plugin install` busca el CLI de Orca (en el `PATH` o donde lo deja el instalador de Orca; `OMK_ORCA` para indicar otro) y comprueba que su versión cumple `engines.orca`. Después:
|
|
55
|
+
|
|
56
|
+
- **No está instalado**: `orca plugin install <kit>/orca-plugin`. Orca contesta `approval_required` con lo que concedería; omk lo enseña y pregunta `¿Apruebas este acceso? [s/N]`. Solo con un sí repite la orden con `--approve <huella>`, la que da Orca, y solo si tiene el formato esperado. Sin terminal interactivo no aprueba nada: hay que repetir con `--yes`, que es tu aprobación dada de antemano.
|
|
57
|
+
- **Otra versión instalada desde esta carpeta**: `orca plugin update` (Orca vuelve a copiar la carpeta; si la versión nueva pide más acceso, se pregunta otra vez).
|
|
58
|
+
- **Otra versión instalada desde otra carpeta**: no la toca y dice cómo cambiarla (`omk plugin uninstall && omk plugin install`).
|
|
59
|
+
- **Esta versión, pendiente de aprobación**: `orca plugin enable` con el mismo flujo de aprobación.
|
|
60
|
+
- **Esta versión, desactivada por ti**: se respeta.
|
|
61
|
+
|
|
62
|
+
El plugin queda como `local.multiagent-kit`. A mano, sin omk: `orca plugin install ./orca-plugin --json` y, tras revisar lo que lista `error.data`, el comando con `--approve <fingerprint>` que da Orca. La huella está ligada a esta versión, sus ficheros y su acceso.
|
|
63
|
+
|
|
64
|
+
## Ajustes
|
|
65
|
+
|
|
66
|
+
Dos sitios, los mismos valores (cambiar uno cambia el otro, y el worker se entera al momento):
|
|
58
67
|
|
|
59
|
-
|
|
68
|
+
- El panel *Multiagent Kit* de la barra lateral derecha.
|
|
69
|
+
- *Settings → Plugins → Orca Multiagent Kit*, la página que Orca genera con los ajustes que declara el manifiesto (`contributes.settings`).
|
|
60
70
|
|
|
61
71
|
| Ajuste | Por defecto | Valores |
|
|
62
72
|
|---|---|---|
|
|
@@ -82,7 +92,6 @@ Sin plugin, el kit sigue funcionando igual. Solo se pierden la paleta, la barra
|
|
|
82
92
|
DEFERRED:
|
|
83
93
|
- **Progreso del run en la barra** (`ronda 1 · 2/3 unidades`): exige leer `.work/runs/<run>/units.md`, y la API de Orca no da acceso a ficheros a los workers. Hoy el coordinador lo deja en el comentario del worktree (`orca worktree set --comment`).
|
|
84
94
|
- **Instalación desde Git** (`orca plugin install FernandoBaqueroo/orca-multiagent-kit`): la ayuda de `orca plugin install` (1.4.252) no documenta instalar desde una subcarpeta del repositorio. Haría falta un repo propio para el plugin o confirmar que Orca acepta una URL `tree/<ref>/orca-plugin`.
|
|
85
|
-
- **Instalación automática** con `install.sh` / `omk install`: ahora se instala a mano. Para hacerlo automático hay que tocar el instalador, y se deja para otro PR.
|
|
86
95
|
- **Preparar worktrees nuevos** (`workspace.create.after`): ya lo hacen `orca.yaml` (`scripts.setup`, `sharedDirectories`), `.worktreeinclude` y `worker-start --setup run`, que la skill pasa siempre; un hook duplicaría ese trabajo.
|
|
87
96
|
- **Rol y modelo en la barra de estado**: la barra cuenta agentes por estado, pero no sabe qué rol de Olimpo ni qué nivel de modelo tiene cada uno; eso está en `.work/runs/<run>/run.md`, que el plugin no puede leer.
|
|
88
97
|
|
|
@@ -90,13 +99,13 @@ DEFERRED:
|
|
|
90
99
|
|
|
91
100
|
```bash
|
|
92
101
|
orca plugin validate orca-plugin --json # manifiesto como lo carga Orca
|
|
93
|
-
orca plugin test orca-plugin --json #
|
|
102
|
+
orca plugin test orca-plugin --json # 48 pruebas: src/kit.test.ts, src/worker.test.ts y src/panel.test.tsx
|
|
94
103
|
orca plugin check orca-plugin --json
|
|
95
104
|
orca plugin inspect orca-plugin --json # qué aporta y qué acceso pide
|
|
96
105
|
bash scripts/check.sh # comprobación estática del manifiesto, también en CI (sin Orca)
|
|
97
106
|
```
|
|
98
107
|
|
|
99
|
-
Las pruebas usan `orca/testing`: `mountWorker` sobre un host simulado con las capacidades del manifiesto. Cubren el hook (con y sin cabecera del kit, otros `inputKind`, el modo apagado e idempotencia), los comandos (literal enviado, workspace sin identificar, fallo de Orca notificado, id de agente hostil) y la barra (eventos, siembra inicial, desactivada). La detección de `omk` ausente se prueba con los mensajes reales de cada shell.
|
|
108
|
+
Las pruebas usan `orca/testing`: `mountWorker` sobre un host simulado con las capacidades del manifiesto. Cubren el hook (con y sin cabecera del kit, otros `inputKind`, el modo apagado e idempotencia), los comandos (literal enviado, workspace sin identificar, fallo de Orca notificado, id de agente hostil) y la barra (eventos, siembra inicial, desactivada). El panel se prueba con `mount`: ajustes leídos y guardados, id de agente no válido rechazado, cada botón con su acción, un fallo del worker enseñado y los agentes que envía el worker; y el worker rechaza cualquier acción del panel fuera de las tres. La detección de `omk` ausente se prueba con los mensajes reales de cada shell.
|
|
100
109
|
|
|
101
110
|
Para probarlo en Orca sin instalarlo: `orca plugin dev watch orca-plugin --json`. También pide aprobación, y `Ctrl-C` lo descarga.
|
|
102
111
|
|
|
@@ -2,8 +2,8 @@
|
|
|
2
2
|
"manifestVersion": 2,
|
|
3
3
|
"id": "multiagent-kit",
|
|
4
4
|
"name": "Orca Multiagent Kit",
|
|
5
|
-
"version": "0.
|
|
6
|
-
"description": "Comandos del kit en la paleta, el contrato del worker en cada despacho de orquestación del kit y los agentes activos en la barra de estado.",
|
|
5
|
+
"version": "0.2.0",
|
|
6
|
+
"description": "Comandos del kit en la paleta, un panel con las acciones y los ajustes, el contrato del worker en cada despacho de orquestación del kit y los agentes activos en la barra de estado.",
|
|
7
7
|
"author": {
|
|
8
8
|
"name": "Fernando Baquero y Necro-Coder",
|
|
9
9
|
"url": "https://github.com/FernandoBaqueroo/orca-multiagent-kit"
|
|
@@ -27,6 +27,9 @@
|
|
|
27
27
|
{ "kind": "settings:own" }
|
|
28
28
|
],
|
|
29
29
|
"contributes": {
|
|
30
|
+
"panels": [
|
|
31
|
+
{ "id": "kit", "title": "Multiagent Kit", "icon": "bot", "entry": "src/panel.tsx", "ui": "components" }
|
|
32
|
+
],
|
|
30
33
|
"commands": [
|
|
31
34
|
{ "id": "kit.verify", "title": "Orca Multiagent Kit: verificar instalación", "when": "workspace" },
|
|
32
35
|
{ "id": "kit.init", "title": "Orca Multiagent Kit: inicializar proyecto", "when": "workspace" },
|
package/orca-plugin/src/kit.ts
CHANGED
|
@@ -69,7 +69,8 @@ export async function pollUntil(
|
|
|
69
69
|
}
|
|
70
70
|
|
|
71
71
|
export const INSTALL_HINT =
|
|
72
|
-
'Instálalo con `npm install -g orca-multiagent-kit`
|
|
72
|
+
'Instálalo con `npm install -g orca-multiagent-kit` o con el ejecutable de la última release (lo deja en el PATH), ' +
|
|
73
|
+
'reinicia Orca y vuelve a lanzar el comando.'
|
|
73
74
|
|
|
74
75
|
export type FocusedWorkspace = { branch: string; displayName: string }
|
|
75
76
|
export type WorkspaceEntry = { id: string; name: string; branch: string | null }
|
|
@@ -90,6 +91,15 @@ export function resolveFocusedWorkspaceId(
|
|
|
90
91
|
return matches.length === 1 ? (matches[0]?.id ?? null) : null
|
|
91
92
|
}
|
|
92
93
|
|
|
94
|
+
/** Acciones del kit que lanzan la paleta y el panel. */
|
|
95
|
+
export type KitAction = 'verify' | 'update' | 'init'
|
|
96
|
+
|
|
97
|
+
export const KIT_ACTIONS: readonly KitAction[] = ['verify', 'update', 'init']
|
|
98
|
+
|
|
99
|
+
export function isKitAction(value: unknown): value is KitAction {
|
|
100
|
+
return KIT_ACTIONS.some((action) => action === value)
|
|
101
|
+
}
|
|
102
|
+
|
|
93
103
|
const AGENT_ID = /^[a-z0-9][a-z0-9-]{0,39}$/
|
|
94
104
|
|
|
95
105
|
export function isValidAgentId(value: unknown): value is string {
|
|
@@ -130,12 +140,20 @@ export function summarizeAgents(agents: Iterable<TrackedAgent>): AgentSummary {
|
|
|
130
140
|
}
|
|
131
141
|
}
|
|
132
142
|
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
143
|
+
export type AgentLine = { title: string; state: string }
|
|
144
|
+
|
|
145
|
+
/** Los agentes activos con su estado en texto, para el panel y el comando. */
|
|
146
|
+
export function agentLines(agents: Iterable<TrackedAgent>): AgentLine[] {
|
|
147
|
+
const lines: AgentLine[] = []
|
|
136
148
|
for (const agent of agents) {
|
|
137
149
|
if (agent.state === 'done') continue
|
|
138
|
-
lines.push(
|
|
150
|
+
lines.push({ title: agent.title ?? 'agente sin título', state: STATE_LABEL[agent.state][0] })
|
|
139
151
|
}
|
|
152
|
+
return lines
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
/** Una línea por agente activo, para el comando «estado de los agentes». */
|
|
156
|
+
export function describeAgents(agents: Iterable<TrackedAgent>): string {
|
|
157
|
+
const lines = agentLines(agents).map(({ title, state }) => `- ${title}: ${state}`)
|
|
140
158
|
return lines.length > 0 ? lines.join('\n') : 'Ningún agente activo.'
|
|
141
159
|
}
|