aegiscode 6.8.19 → 6.8.20
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/package.json +4 -2
- package/scripts/check.mjs +50 -0
- package/scripts/predist.mjs +11 -0
- package/src/commands.js +41 -35
- package/src/devrun.js +80 -6
- package/src/panels.js +2 -1
- package/src/summarize.js +3 -1
- package/vendor/client/aegis.js +13 -0
- package/vendor/client/authorship-key.js +45 -4
- package/vendor/client/byok-catalog.js +49 -1
- package/vendor/client/hooks.js +427 -0
- package/vendor/client/platform.js +410 -0
- package/vendor/desktop/lib/local/engine.js +85 -3
- package/vendor/desktop/lib/local/shell.js +393 -39
- package/vendor/desktop/lib/local/tools.js +156 -13
- package/vendor/desktop/lib/settings.js +36 -1
- package/vendor/desktop/renderer/usage.js +30 -0
- package/vendor/tools/agent-gate.mjs +81 -13
|
@@ -7,26 +7,308 @@
|
|
|
7
7
|
* The desktop `exec` tool used to spawn ONE process per call: `cd /foo` in
|
|
8
8
|
* one turn had no effect on the next call, so a model that wanted to work
|
|
9
9
|
* inside a subdirectory had to prefix every single command with `cd X &&`.
|
|
10
|
-
* This keeps ONE long-lived shell per chat turn — bash on
|
|
11
|
-
* PowerShell on Windows (no bash there by default) — feeding it
|
|
12
|
-
* stdin and framing each command's output with a per-session
|
|
13
|
-
* printed alongside the exit code. On
|
|
14
|
-
* (`exec 2>&1`) so ordering is preserved; PowerShell's stderr pipe
|
|
15
|
-
* the same way by listening on both streams.
|
|
10
|
+
* This keeps ONE long-lived shell per chat turn — a probed POSIX sh/bash on
|
|
11
|
+
* macOS/Linux, PowerShell on Windows (no bash there by default) — feeding it
|
|
12
|
+
* commands over stdin and framing each command's output with a per-session
|
|
13
|
+
* random sentinel printed alongside the exit code. On POSIX, stderr is merged
|
|
14
|
+
* into stdout (`exec 2>&1`) so ordering is preserved; PowerShell's stderr pipe
|
|
15
|
+
* is merged the same way by listening on both streams.
|
|
16
16
|
*
|
|
17
|
-
*
|
|
18
|
-
*
|
|
19
|
-
*
|
|
17
|
+
* Phase 30.3 — the shell is PROBED, never assumed. Until this step the session
|
|
18
|
+
* spawned `process.env.SHELL || '/bin/bash'` and then fed it brace groups, `exec
|
|
19
|
+
* 2>&1` and `$?` — all POSIX-only. Windows was handled; a POSIX host whose
|
|
20
|
+
* `$SHELL` is fish, csh or nushell was not, and those three reject that syntax
|
|
21
|
+
* outright (a brace group to fish is not a syntax error you can ignore: it
|
|
22
|
+
* silently runs the wrong thing and eats the sentinel, hanging the session to
|
|
23
|
+
* its timeout). So `resolveSessionShell()` below only ever returns a shell it
|
|
24
|
+
* has actually EXECUTED once with a POSIX-only probe script, and the dialect the
|
|
25
|
+
* script builder uses follows the verified dialect — `this.shell.kind` — rather
|
|
26
|
+
* than the OS. A `$SHELL` naming a known-non-POSIX shell (fish/csh/tcsh/nu/
|
|
27
|
+
* xonsh) is never adopted and never probed; it is named in the evidence trail
|
|
28
|
+
* and in the caveat, and if no sh/bash can be verified at all the session
|
|
29
|
+
* REFUSES with a message naming it, instead of quietly feeding it POSIX syntax.
|
|
30
|
+
*
|
|
31
|
+
* Self-contained (node:child_process + node:crypto + the shared
|
|
32
|
+
* client/platform.js) and never throws: run() always resolves
|
|
33
|
+
* { content, isError }. If the session can't start or dies, run() falls back to
|
|
34
|
+
* a one-shot spawn so `exec` keeps working.
|
|
20
35
|
*/
|
|
21
36
|
|
|
22
|
-
const { spawn } = require('node:child_process');
|
|
37
|
+
const { spawn, spawnSync } = require('node:child_process');
|
|
23
38
|
const crypto = require('node:crypto');
|
|
24
39
|
|
|
25
|
-
|
|
40
|
+
// The ONE platform module (client/platform.js, Phase 30.1) — resolved the same
|
|
41
|
+
// two ways this repo resolves every shared module (see tools.js/engine.js):
|
|
42
|
+
// repo-relative in a checkout and in the CLI's mirrored vendor tree, then the
|
|
43
|
+
// staged app-dir copy a packaged desktop build carries. Executable lookup goes
|
|
44
|
+
// through it (`resolveExecutable`) rather than through a path literal, so the
|
|
45
|
+
// Windows half of that search is exercised by tests on this Linux host.
|
|
46
|
+
let platform;
|
|
47
|
+
try {
|
|
48
|
+
platform = require('../../../client/platform.js');
|
|
49
|
+
} catch (err) {
|
|
50
|
+
try {
|
|
51
|
+
platform = require('../../vendor/platform.js');
|
|
52
|
+
} catch {
|
|
53
|
+
throw new Error(
|
|
54
|
+
`shell.js: cannot load the shared platform module (client/platform.js, ` +
|
|
55
|
+
`or its staged copy): ${err && err.message ? err.message : err}`
|
|
56
|
+
);
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
const IS_WIN32 = platform.IS_WIN32;
|
|
26
61
|
const OUTPUT_CAP = 30_000;
|
|
27
62
|
const MAX_TIMEOUT = 600_000;
|
|
28
63
|
const DEFAULT_TIMEOUT = 120_000;
|
|
29
64
|
|
|
65
|
+
// ---------------------------------------------------------------------------
|
|
66
|
+
// Dialect resolution (Phase 30.3)
|
|
67
|
+
// ---------------------------------------------------------------------------
|
|
68
|
+
|
|
69
|
+
/**
|
|
70
|
+
* The shells whose `-c` we are allowed to treat as POSIX sh. Anything else —
|
|
71
|
+
* fish, csh/tcsh, nushell, xonsh, elvish, pwsh — is a different LANGUAGE, not a
|
|
72
|
+
* differently-named sh: it is never spawned for a session and never handed the
|
|
73
|
+
* brace-group framing below.
|
|
74
|
+
*/
|
|
75
|
+
const POSIX_SHELL_NAMES = ['bash', 'sh', 'dash', 'ksh', 'zsh'];
|
|
76
|
+
|
|
77
|
+
/** Substitute candidates, in order, when `$SHELL` is unusable. */
|
|
78
|
+
const POSIX_FALLBACK_NAMES = ['bash', 'sh'];
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* The probe script: builtins only (no PATH, no filesystem, no output), and
|
|
82
|
+
* POSIX-only syntax — fish, csh and nu all reject this construct, so a clean
|
|
83
|
+
* exit 0 is evidence that `-c` really runs POSIX sh here, rather than evidence
|
|
84
|
+
* that a binary with the right name exists. Same probe the engine's Phase 21b
|
|
85
|
+
* resolution uses.
|
|
86
|
+
*/
|
|
87
|
+
const POSIX_PROBE = 'if [ 1 -eq 1 ]; then exit 0; fi';
|
|
88
|
+
const SHELL_PROBE_TIMEOUT = 4000;
|
|
89
|
+
|
|
90
|
+
/** Last path segment of a shell reference, minus a `.exe`, lower-cased. */
|
|
91
|
+
function shellName(cmd) {
|
|
92
|
+
return String(cmd || '')
|
|
93
|
+
.trim()
|
|
94
|
+
.split(/[\\/]/)
|
|
95
|
+
.pop()
|
|
96
|
+
.toLowerCase()
|
|
97
|
+
.replace(/\.exe$/, '');
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
/** True for the shells whose `-c` may be treated as POSIX sh. */
|
|
101
|
+
function isPosixShellName(cmd) {
|
|
102
|
+
return POSIX_SHELL_NAMES.includes(shellName(cmd));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
/** The real probe: spawn `cmd -c <POSIX_PROBE>`, true only on a clean exit 0. */
|
|
106
|
+
function probePosixShell(cmd, { env, timeout = SHELL_PROBE_TIMEOUT } = {}) {
|
|
107
|
+
try {
|
|
108
|
+
const res = spawnSync(cmd, ['-c', POSIX_PROBE], {
|
|
109
|
+
env,
|
|
110
|
+
encoding: 'utf8',
|
|
111
|
+
timeout,
|
|
112
|
+
windowsHide: true,
|
|
113
|
+
stdio: 'ignore',
|
|
114
|
+
});
|
|
115
|
+
return !res.error && res.status === 0;
|
|
116
|
+
} catch {
|
|
117
|
+
return false;
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
/** Normalize the injected seams, defaulting each to the real thing. */
|
|
122
|
+
function shellSeams(options) {
|
|
123
|
+
const o = options && typeof options === 'object' ? options : {};
|
|
124
|
+
return {
|
|
125
|
+
platform: typeof o.platform === 'string' && o.platform ? o.platform : process.platform,
|
|
126
|
+
env: o.env && typeof o.env === 'object' ? o.env : process.env,
|
|
127
|
+
exists: typeof o.exists === 'function' ? o.exists : undefined,
|
|
128
|
+
probe: typeof o.probe === 'function' ? o.probe : undefined,
|
|
129
|
+
injected: typeof o.probe === 'function' || typeof o.exists === 'function',
|
|
130
|
+
};
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/**
|
|
134
|
+
* Try one candidate. Returns a verified spec or null, recording why in `tried`
|
|
135
|
+
* and every shell it actually executed in `executed`.
|
|
136
|
+
*
|
|
137
|
+
* The name gate comes FIRST and applies to every candidate, including `$SHELL`:
|
|
138
|
+
* fish is refused on its name, before a probe could ever adopt it, so there is
|
|
139
|
+
* no ordering in which a fish gets spawned and then handed POSIX syntax.
|
|
140
|
+
*/
|
|
141
|
+
function considerPosixCandidate(o, candidate, tried, executed) {
|
|
142
|
+
const raw = String(candidate.cmd || '').trim();
|
|
143
|
+
if (!raw) {
|
|
144
|
+
tried.push({ candidate: candidate.source || '(unset)', ok: false, reason: 'unset' });
|
|
145
|
+
return null;
|
|
146
|
+
}
|
|
147
|
+
if (!isPosixShellName(raw)) {
|
|
148
|
+
tried.push({
|
|
149
|
+
candidate: raw,
|
|
150
|
+
ok: false,
|
|
151
|
+
reason:
|
|
152
|
+
`${candidate.source || 'candidate'} is not a POSIX shell — ${shellName(raw) || raw} is a ` +
|
|
153
|
+
'different language (fish/csh/nu), so it was never executed and never sent POSIX syntax',
|
|
154
|
+
});
|
|
155
|
+
return null;
|
|
156
|
+
}
|
|
157
|
+
const resolved = platform.resolveExecutable(raw, {
|
|
158
|
+
platform: o.platform,
|
|
159
|
+
env: o.env,
|
|
160
|
+
exists: o.exists,
|
|
161
|
+
});
|
|
162
|
+
if (!resolved) {
|
|
163
|
+
tried.push({
|
|
164
|
+
candidate: raw,
|
|
165
|
+
ok: false,
|
|
166
|
+
reason: /[\\/]/.test(raw) ? 'not present' : 'not found on PATH',
|
|
167
|
+
});
|
|
168
|
+
return null;
|
|
169
|
+
}
|
|
170
|
+
const ok = o.probe
|
|
171
|
+
? Boolean(o.probe(resolved, ['-c', POSIX_PROBE]))
|
|
172
|
+
: probePosixShell(resolved, { env: o.env });
|
|
173
|
+
executed.push(resolved);
|
|
174
|
+
if (!ok) {
|
|
175
|
+
tried.push({
|
|
176
|
+
candidate: resolved,
|
|
177
|
+
ok: false,
|
|
178
|
+
reason: `failed the POSIX probe (\`-c\` with \`${POSIX_PROBE}\` did not exit 0) — refused`,
|
|
179
|
+
});
|
|
180
|
+
return null;
|
|
181
|
+
}
|
|
182
|
+
tried.push({
|
|
183
|
+
candidate: resolved,
|
|
184
|
+
ok: true,
|
|
185
|
+
reason: 'verified: one `-c` POSIX script exited 0',
|
|
186
|
+
});
|
|
187
|
+
return { ok: true, cmd: resolved, arg: '-c', kind: 'posix-sh', source: candidate.source, verified: true };
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
/**
|
|
191
|
+
* Resolve the session shell on a POSIX host, with the evidence for the answer.
|
|
192
|
+
*
|
|
193
|
+
* Returns { ok, cmd, arg, kind, source, verified, unsupported, caveat, error,
|
|
194
|
+
* tried[] }:
|
|
195
|
+
*
|
|
196
|
+
* - `$SHELL` wins when it NAMES a POSIX shell and passes the probe;
|
|
197
|
+
* - a `$SHELL` naming fish/csh/nu/xonsh (or anything else non-POSIX, including
|
|
198
|
+
* garbage) is refused by name, recorded in `tried`, and named in `caveat`
|
|
199
|
+
* when a substitute is found and in `error` when none can be;
|
|
200
|
+
* - when `$SHELL` is unusable the POSIX dialect runs through an explicit
|
|
201
|
+
* `bash`/`sh` found on PATH — resolved by client/platform.js, not by a path
|
|
202
|
+
* literal — and only after that substitute passed the probe itself;
|
|
203
|
+
* - `ok:false` means NO shell was verified: the caller must report `error`
|
|
204
|
+
* (which names the unsupported `$SHELL`) instead of spawning anything.
|
|
205
|
+
*/
|
|
206
|
+
function resolvePosixSessionShell(o) {
|
|
207
|
+
const tried = [];
|
|
208
|
+
const executed = [];
|
|
209
|
+
const envShell = String((o.env && o.env.SHELL) || '').trim();
|
|
210
|
+
const candidates = [];
|
|
211
|
+
|
|
212
|
+
if (!envShell) {
|
|
213
|
+
tried.push({ candidate: '$SHELL', ok: false, reason: '$SHELL is unset' });
|
|
214
|
+
} else {
|
|
215
|
+
candidates.push({ cmd: envShell, source: '$SHELL' });
|
|
216
|
+
}
|
|
217
|
+
for (const name of POSIX_FALLBACK_NAMES) {
|
|
218
|
+
candidates.push({ cmd: name, source: `PATH:${name}` });
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
let hit = null;
|
|
222
|
+
for (const candidate of candidates) {
|
|
223
|
+
hit = considerPosixCandidate(o, candidate, tried, executed);
|
|
224
|
+
if (hit) break;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
const unsupported = envShell && !isPosixShellName(envShell) ? envShell : null;
|
|
228
|
+
if (hit) {
|
|
229
|
+
return {
|
|
230
|
+
...hit,
|
|
231
|
+
unsupported,
|
|
232
|
+
caveat: unsupported
|
|
233
|
+
? `$SHELL is ${unsupported}, which is not a POSIX shell — the session runs the POSIX ` +
|
|
234
|
+
`dialect through ${hit.cmd} instead, and ${unsupported} is never sent brace groups, ` +
|
|
235
|
+
'`exec 2>&1` or `$?`'
|
|
236
|
+
: null,
|
|
237
|
+
error: null,
|
|
238
|
+
executed,
|
|
239
|
+
tried,
|
|
240
|
+
};
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
const error = unsupported
|
|
244
|
+
? `exec: refusing to run — $SHELL is "${unsupported}", which is not a POSIX shell ` +
|
|
245
|
+
'(fish/csh/nushell are a different language), and no sh/bash could be verified on PATH ' +
|
|
246
|
+
'to run the POSIX dialect instead. Set SHELL to bash or sh, or put one on PATH.'
|
|
247
|
+
: `exec: no POSIX shell available — $SHELL is ${envShell ? `"${envShell}"` : 'unset'} and no ` +
|
|
248
|
+
'sh/bash passed the POSIX probe; set SHELL to bash or sh, or put one on PATH.';
|
|
249
|
+
return {
|
|
250
|
+
ok: false,
|
|
251
|
+
cmd: null,
|
|
252
|
+
arg: null,
|
|
253
|
+
kind: null,
|
|
254
|
+
source: 'refused',
|
|
255
|
+
verified: false,
|
|
256
|
+
unsupported,
|
|
257
|
+
caveat: null,
|
|
258
|
+
error,
|
|
259
|
+
executed,
|
|
260
|
+
tried,
|
|
261
|
+
};
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
// Verified verdicts are cached per (platform, $SHELL, PATH) so the probe runs
|
|
265
|
+
// once per process — but never when a seam was injected: a test double must not
|
|
266
|
+
// be able to poison the real verdicts.
|
|
267
|
+
const SHELL_CACHE = new Map();
|
|
268
|
+
|
|
269
|
+
/**
|
|
270
|
+
* Which shell runs the session here, and the evidence for that answer.
|
|
271
|
+
*
|
|
272
|
+
* Windows keeps PowerShell (there is no bash there by default), exactly as
|
|
273
|
+
* before; everywhere else the answer comes from resolvePosixSessionShell above
|
|
274
|
+
* and is only ever a shell that passed the POSIX probe. `options` is the same
|
|
275
|
+
* injected seam the shared platform module takes —
|
|
276
|
+
* `{ platform, env, exists, probe }` — so every branch is exercised on this
|
|
277
|
+
* Linux host (test/shell-dialect.test.mjs) rather than on a runner this project
|
|
278
|
+
* does not have.
|
|
279
|
+
*/
|
|
280
|
+
function resolveSessionShell(options = {}) {
|
|
281
|
+
const o = shellSeams(options);
|
|
282
|
+
if (o.platform === 'win32') {
|
|
283
|
+
const spec = platform.shellSpec({ platform: 'win32', env: o.env });
|
|
284
|
+
const powershell =
|
|
285
|
+
platform.resolveExecutable('powershell', { platform: 'win32', env: o.env, exists: o.exists }) ||
|
|
286
|
+
'powershell.exe';
|
|
287
|
+
return {
|
|
288
|
+
ok: true,
|
|
289
|
+
cmd: powershell,
|
|
290
|
+
arg: '-',
|
|
291
|
+
kind: 'powershell',
|
|
292
|
+
source: 'powershell.exe',
|
|
293
|
+
verified: true,
|
|
294
|
+
unsupported: null,
|
|
295
|
+
caveat: null,
|
|
296
|
+
error: null,
|
|
297
|
+
// One-shot commands on Windows stay cmd.exe: that is what the pre-session
|
|
298
|
+
// `exec` always used, and PowerShell is only the session's dialect.
|
|
299
|
+
oneShot: spec,
|
|
300
|
+
executed: [],
|
|
301
|
+
tried: [{ candidate: powershell, ok: true, reason: 'the Windows default (PowerShell session, cmd.exe one-shot)' }],
|
|
302
|
+
};
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
const key = [o.platform, o.env && o.env.SHELL, o.env && o.env.PATH].join('\u0000');
|
|
306
|
+
if (!o.injected && SHELL_CACHE.has(key)) return SHELL_CACHE.get(key);
|
|
307
|
+
const spec = resolvePosixSessionShell(o);
|
|
308
|
+
if (!o.injected) SHELL_CACHE.set(key, spec);
|
|
309
|
+
return spec;
|
|
310
|
+
}
|
|
311
|
+
|
|
30
312
|
function cap(s) {
|
|
31
313
|
return s.length > OUTPUT_CAP ? `${s.slice(0, OUTPUT_CAP)}\n… (truncated)` : s;
|
|
32
314
|
}
|
|
@@ -65,14 +347,49 @@ function appendBounded(prev, chunk) {
|
|
|
65
347
|
return next.slice(0, OUTPUT_CAP) + ELISION + next.slice(-TAIL_KEEP);
|
|
66
348
|
}
|
|
67
349
|
|
|
68
|
-
/**
|
|
69
|
-
|
|
350
|
+
/**
|
|
351
|
+
* The spec for a ONE-SHOT command (no live session) — the same resolution, so
|
|
352
|
+
* the `exec` tool's no-session path and this module's fallback cannot disagree
|
|
353
|
+
* about which shell speaks the dialect the command was written in.
|
|
354
|
+
*
|
|
355
|
+
* Windows keeps cmd.exe (`/d /s /c`), exactly what it used before; everywhere
|
|
356
|
+
* else the answer is a PROBED POSIX sh/bash, and `{ ok:false, error }` when
|
|
357
|
+
* nothing could be verified — the caller reports `error` (which names the
|
|
358
|
+
* unsupported `$SHELL`) instead of shelling out in a language it does not speak.
|
|
359
|
+
*/
|
|
360
|
+
function oneShotShellSpec(options = {}) {
|
|
361
|
+
const spec = resolveSessionShell(options);
|
|
362
|
+
if (!spec.ok) {
|
|
363
|
+
return { ok: false, cmd: null, arg: null, kind: null, error: spec.error, spec };
|
|
364
|
+
}
|
|
365
|
+
if (spec.kind === 'powershell') {
|
|
366
|
+
const cmdSpec = platform.shellSpec({ platform: 'win32', env: shellSeams(options).env });
|
|
367
|
+
return { ok: true, cmd: cmdSpec.cmd, arg: cmdSpec.arg, kind: 'cmd', error: null, spec };
|
|
368
|
+
}
|
|
369
|
+
return { ok: true, cmd: spec.cmd, arg: spec.arg, kind: 'posix-sh', error: null, spec };
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
/**
|
|
373
|
+
* One-shot fallback — the pre-session behavior, used when no live session.
|
|
374
|
+
*
|
|
375
|
+
* The dialect is resolved the same way the session's is: a POSIX `-c` runs in a
|
|
376
|
+
* verified sh/bash (never in an unprobed `$SHELL`), and when nothing can be
|
|
377
|
+
* verified the refusal names the shell that was refused rather than shelling out
|
|
378
|
+
* to it in a language it does not speak.
|
|
379
|
+
*/
|
|
380
|
+
function oneShotShell({ command, timeout = DEFAULT_TIMEOUT, working_directory, shellOptions } = {}) {
|
|
70
381
|
return new Promise((resolve) => {
|
|
71
|
-
const
|
|
72
|
-
const
|
|
73
|
-
|
|
382
|
+
const o = shellSeams(shellOptions);
|
|
383
|
+
const spec = resolveSessionShell(shellOptions);
|
|
384
|
+
if (!spec || !spec.ok) {
|
|
385
|
+
resolve({ content: (spec && spec.error) || 'exec: no usable shell', isError: true });
|
|
386
|
+
return;
|
|
387
|
+
}
|
|
388
|
+
const call = spec.kind === 'powershell' ? spec.oneShot : spec;
|
|
389
|
+
const child = spawn(call.cmd, [call.arg, String(command || '')], {
|
|
74
390
|
cwd: working_directory || process.cwd(),
|
|
75
391
|
timeout: Math.min(Number(timeout) || DEFAULT_TIMEOUT, MAX_TIMEOUT),
|
|
392
|
+
env: o.env,
|
|
76
393
|
});
|
|
77
394
|
let out = '';
|
|
78
395
|
let err = '';
|
|
@@ -89,30 +406,44 @@ function oneShotShell({ command, timeout = DEFAULT_TIMEOUT, working_directory }
|
|
|
89
406
|
}
|
|
90
407
|
|
|
91
408
|
class ShellSession {
|
|
92
|
-
constructor({ cwd } = {}) {
|
|
409
|
+
constructor({ cwd, shellOptions } = {}) {
|
|
93
410
|
this.sentinel = `__AEGIS_SH_${crypto.randomBytes(8).toString('hex')}__`;
|
|
94
411
|
this.marker = `${this.sentinel}EXIT:`;
|
|
95
412
|
this.buf = '';
|
|
96
413
|
this.alive = false;
|
|
97
414
|
this._pending = null; // resolver-scan for the in-flight command
|
|
415
|
+
this.shellOptions = shellOptions || {};
|
|
416
|
+
// Resolved BEFORE anything is spawned or written: `shell.kind` is what the
|
|
417
|
+
// command framing below branches on, so an unverified `$SHELL` can never
|
|
418
|
+
// receive POSIX syntax — it is never spawned at all.
|
|
419
|
+
this.shell = resolveSessionShell(this.shellOptions);
|
|
420
|
+
this.shellError = this.shell.ok ? null : this.shell.error;
|
|
98
421
|
this._start(cwd);
|
|
99
422
|
}
|
|
100
423
|
|
|
101
424
|
_start(cwd) {
|
|
425
|
+
if (!this.shell || !this.shell.ok) {
|
|
426
|
+
// Refused: no shell was verified, so nothing is spawned. run() reports
|
|
427
|
+
// this.shellError (which names the unsupported $SHELL).
|
|
428
|
+
this.alive = false;
|
|
429
|
+
return;
|
|
430
|
+
}
|
|
431
|
+
const env = shellSeams(this.shellOptions).env;
|
|
102
432
|
try {
|
|
103
|
-
this.child =
|
|
433
|
+
this.child = this.shell.kind === 'powershell'
|
|
104
434
|
// -Command - reads the script from stdin as a non-interactive session,
|
|
105
435
|
// so there are no prompts to pollute output, but state still persists.
|
|
106
|
-
? spawn(
|
|
436
|
+
? spawn(this.shell.cmd, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '-'], {
|
|
107
437
|
cwd: cwd || process.cwd(),
|
|
108
|
-
env
|
|
438
|
+
env,
|
|
109
439
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
110
440
|
})
|
|
111
441
|
// No args → the shell reads commands from stdin as a non-interactive
|
|
112
442
|
// script, so there are no prompts to pollute output, but state persists.
|
|
113
|
-
|
|
443
|
+
// This is a shell that PASSED the POSIX probe (see resolveSessionShell).
|
|
444
|
+
: spawn(this.shell.cmd, [], {
|
|
114
445
|
cwd: cwd || process.cwd(),
|
|
115
|
-
env
|
|
446
|
+
env,
|
|
116
447
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
117
448
|
});
|
|
118
449
|
} catch {
|
|
@@ -133,8 +464,10 @@ class ShellSession {
|
|
|
133
464
|
// Merge stderr into stdout for the whole session so output ordering is
|
|
134
465
|
// faithful and the sentinel (printed to fd1) always lands after it.
|
|
135
466
|
// PowerShell errors already arrive on the stderr pipe onData folds in
|
|
136
|
-
// above, so only
|
|
137
|
-
|
|
467
|
+
// above, so only a POSIX session needs the explicit redirect — and `exec`
|
|
468
|
+
// redirection is POSIX, which is why this is gated on the VERIFIED dialect
|
|
469
|
+
// rather than on `!IS_WIN32`.
|
|
470
|
+
if (this.shell.kind === 'posix-sh') {
|
|
138
471
|
try { this.child.stdin.write('exec 2>&1\n'); } catch { this.alive = false; }
|
|
139
472
|
}
|
|
140
473
|
}
|
|
@@ -143,12 +476,16 @@ class ShellSession {
|
|
|
143
476
|
* Run one command in the session. Resolves { content, isError }. A dead or
|
|
144
477
|
* unstartable session (or a working_directory that must not persist)
|
|
145
478
|
* degrades gracefully. `working_directory` is scoped to this one command (a
|
|
146
|
-
* subshell on
|
|
479
|
+
* subshell on POSIX, Push-Location/Pop-Location on PowerShell) so it doesn't
|
|
147
480
|
* move the session's cwd.
|
|
148
481
|
*/
|
|
149
482
|
run(command, { timeout = DEFAULT_TIMEOUT, working_directory } = {}) {
|
|
150
|
-
|
|
151
|
-
|
|
483
|
+
const posixSession = this.shell && this.shell.kind === 'posix-sh' && this.shell.verified;
|
|
484
|
+
if (!this.alive || !this.child || ((this.shell && this.shell.kind === 'posix-sh') && !posixSession)) {
|
|
485
|
+
if (!this.alive && this.shellError) {
|
|
486
|
+
return Promise.resolve({ content: this.shellError, isError: true });
|
|
487
|
+
}
|
|
488
|
+
return oneShotShell({ command, timeout, working_directory, shellOptions: this.shellOptions });
|
|
152
489
|
}
|
|
153
490
|
let cmd = String(command || '');
|
|
154
491
|
|
|
@@ -188,7 +525,7 @@ class ShellSession {
|
|
|
188
525
|
|
|
189
526
|
// Send the command, then print the sentinel + exit code on its own line.
|
|
190
527
|
let script;
|
|
191
|
-
if (
|
|
528
|
+
if (!posixSession) {
|
|
192
529
|
// Push-Location/Pop-Location scope working_directory to this one
|
|
193
530
|
// command without moving the session's persistent cwd. $__c captures
|
|
194
531
|
// the real exit status before Pop-Location's own success would
|
|
@@ -201,15 +538,17 @@ class ShellSession {
|
|
|
201
538
|
: `${body}\n${exitCapture}\n`;
|
|
202
539
|
script += `Write-Output ("${this.marker}" + $__c)\n`;
|
|
203
540
|
} else {
|
|
204
|
-
//
|
|
205
|
-
//
|
|
206
|
-
//
|
|
207
|
-
//
|
|
208
|
-
//
|
|
209
|
-
//
|
|
210
|
-
//
|
|
211
|
-
// and
|
|
212
|
-
//
|
|
541
|
+
// POSIX dialect, sent ONLY to a shell that passed the POSIX probe
|
|
542
|
+
// (posixSession above) — never to fish/csh/nu. The command runs in a
|
|
543
|
+
// brace group with its stdin redirected from /dev/null: a group (not a
|
|
544
|
+
// subshell) keeps cd/export state persisting, and `</dev/null` stops the
|
|
545
|
+
// command from consuming the control channel. Without this, any
|
|
546
|
+
// stdin-reading command (cat, read, a REPL, ssh, a y/n prompt) swallows
|
|
547
|
+
// the sentinel line that follows it — hanging the whole session until
|
|
548
|
+
// the timeout, and echoing commands (cat) even splice the sentinel into
|
|
549
|
+
// their output and mis-resolve with garbage. working_directory runs in a
|
|
550
|
+
// subshell (parens, not the brace group) so it doesn't move the
|
|
551
|
+
// session's cwd.
|
|
213
552
|
if (working_directory) cmd = `( cd ${shq(working_directory)} && ${cmd} )`;
|
|
214
553
|
const body = cmd.trim() ? cmd : ':';
|
|
215
554
|
script = `{ ${body}\n} </dev/null\nprintf '\\n%s%d\\n' '${this.sentinel}EXIT:' "$?"\n`;
|
|
@@ -218,7 +557,7 @@ class ShellSession {
|
|
|
218
557
|
this.child.stdin.write(script);
|
|
219
558
|
} catch {
|
|
220
559
|
this.alive = false;
|
|
221
|
-
oneShotShell({ command, timeout, working_directory }).then(finish);
|
|
560
|
+
oneShotShell({ command, timeout, working_directory, shellOptions: this.shellOptions }).then(finish);
|
|
222
561
|
return;
|
|
223
562
|
}
|
|
224
563
|
// Data may already be buffered (fast commands) — scan once now.
|
|
@@ -246,4 +585,19 @@ function pshq(s) {
|
|
|
246
585
|
return `'${String(s).replace(/'/g, "''")}'`;
|
|
247
586
|
}
|
|
248
587
|
|
|
249
|
-
module.exports = {
|
|
588
|
+
module.exports = {
|
|
589
|
+
ShellSession,
|
|
590
|
+
oneShotShell,
|
|
591
|
+
IS_WIN32,
|
|
592
|
+
// Phase 30.3: the dialect probe and its verdict, exported so a test can
|
|
593
|
+
// assert on the resolution without spawning a session.
|
|
594
|
+
resolveSessionShell,
|
|
595
|
+
oneShotShellSpec,
|
|
596
|
+
isPosixShellName,
|
|
597
|
+
POSIX_SHELL_NAMES,
|
|
598
|
+
POSIX_PROBE,
|
|
599
|
+
appendBounded,
|
|
600
|
+
OUTPUT_CAP,
|
|
601
|
+
BUFFER_CEILING,
|
|
602
|
+
TAIL_KEEP,
|
|
603
|
+
};
|