@agentshouse/kit 0.2.1-cf6a92e13f031 → 0.2.1-cfbadfb5b5e28
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/README.md +14 -15
- package/dist/acp.js +58 -7
- package/dist/afk.js +17 -0
- package/dist/agents.js +58 -32
- package/dist/authority-main.js +3 -3
- package/dist/bridge.js +4 -4
- package/dist/building.js +50 -0
- package/dist/calls.js +12 -4
- package/dist/chunks.js +49 -0
- package/dist/clis.js +41 -42
- package/dist/connection.js +27 -33
- package/dist/content.js +63 -0
- package/dist/conversations.js +348 -126
- package/dist/copies.js +294 -148
- package/dist/end.js +8 -2
- package/dist/events.js +742 -210
- package/dist/files.js +35 -19
- package/dist/git.js +46 -12
- package/dist/grok.js +39 -0
- package/dist/home.js +0 -7
- package/dist/house-cli.js +26 -13
- package/dist/house-main.js +3 -3
- package/dist/instructions.js +5 -7
- package/dist/kit-cli.js +3 -6
- package/dist/kit-main.js +3 -3
- package/dist/login.js +5 -3
- package/dist/logout.js +1 -1
- package/dist/mcp.js +2 -0
- package/dist/placement.js +10 -18
- package/dist/relay.js +21 -0
- package/dist/resident.js +47 -32
- package/dist/scope.js +12 -4
- package/dist/scripts.js +255 -0
- package/dist/secret-input.js +1 -1
- package/dist/sign-in.js +3 -2
- package/dist/silence.js +28 -0
- package/dist/skills.js +38 -12
- package/dist/transcription.js +37 -25
- package/dist/translate.js +18 -9
- package/dist/update.js +109 -120
- package/dist/wire.js +23 -5
- package/dist/work.js +9 -2
- package/package.json +18 -17
- package/dist/bootstrap.json +0 -24
- package/dist/chatgpt.js +0 -32
- package/dist/clis-main.js +0 -23
- package/dist/parts.js +0 -82
- package/dist/web-wizard.js +0 -100
package/dist/resident.js
CHANGED
|
@@ -10,16 +10,17 @@ import { house } from './api.js';
|
|
|
10
10
|
import { received } from './bridge.js';
|
|
11
11
|
import { CONVERSATION_METHODS, Conversations } from './conversations.js';
|
|
12
12
|
import { LocalCopies } from './copies.js';
|
|
13
|
-
import { restart } from './end.js';
|
|
14
|
-
import { agentBase, enrolled,
|
|
13
|
+
import { restart, unknownMethod } from './end.js';
|
|
14
|
+
import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
|
|
15
15
|
import { Calls } from './calls.js';
|
|
16
16
|
import { killDescendants } from './scope.js';
|
|
17
|
+
import { removeInputs, Scripts } from './scripts.js';
|
|
17
18
|
import { quoted } from './shell.js';
|
|
18
19
|
import { SignIns } from './sign-in.js';
|
|
19
20
|
import { placeSkillSet } from './skills.js';
|
|
20
21
|
import { holdConnection } from './connection.js';
|
|
21
22
|
import { KitUpdate } from './update.js';
|
|
22
|
-
import {
|
|
23
|
+
import { takeUnservedRelease } from './wire.js';
|
|
23
24
|
import { codexLauncher } from './work.js';
|
|
24
25
|
function report(error) {
|
|
25
26
|
process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
|
|
@@ -110,14 +111,7 @@ function connected() {
|
|
|
110
111
|
}
|
|
111
112
|
async function started() {
|
|
112
113
|
await connected();
|
|
113
|
-
await
|
|
114
|
-
watch(kitHome(), () => {
|
|
115
|
-
if (enrolled())
|
|
116
|
-
return;
|
|
117
|
-
killDescendants();
|
|
118
|
-
process.exit(1);
|
|
119
|
-
});
|
|
120
|
-
await placeSkillSet();
|
|
114
|
+
await placeSkillSet((await readEnrolment()).house);
|
|
121
115
|
await mkdir(agentBase(), { recursive: true });
|
|
122
116
|
await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
|
|
123
117
|
await installShim(codexLauncher(), 'codex-main');
|
|
@@ -127,6 +121,7 @@ export async function resident() {
|
|
|
127
121
|
const copies = new LocalCopies(house);
|
|
128
122
|
await copies.load();
|
|
129
123
|
await serveOwner(copies);
|
|
124
|
+
await copies.swept();
|
|
130
125
|
await started().catch((error) => {
|
|
131
126
|
report(error);
|
|
132
127
|
process.exit(1);
|
|
@@ -135,17 +130,28 @@ export async function resident() {
|
|
|
135
130
|
const agents = new Agents(house, () => changed());
|
|
136
131
|
let connection = null;
|
|
137
132
|
let reported = false;
|
|
133
|
+
let stopping = false;
|
|
134
|
+
const stop = async (then) => {
|
|
135
|
+
if (stopping)
|
|
136
|
+
return;
|
|
137
|
+
stopping = true;
|
|
138
|
+
conversations.stopped();
|
|
139
|
+
killDescendants();
|
|
140
|
+
await connection?.close();
|
|
141
|
+
then();
|
|
142
|
+
};
|
|
138
143
|
const idle = () => calls.idle() && conversations.idle() && agents.idle();
|
|
139
144
|
const changed = () => {
|
|
140
145
|
if (!idle()) {
|
|
141
146
|
reported = false;
|
|
142
147
|
}
|
|
143
|
-
else if (
|
|
144
|
-
|
|
148
|
+
else if (update.placedRelease() !== null && conversations.quiet()) {
|
|
149
|
+
const placed = update.placedRelease();
|
|
150
|
+
void stop(() => restart(`Kit ${placed} is placed; its supervisor starts it`));
|
|
145
151
|
}
|
|
146
152
|
else if (!reported) {
|
|
147
153
|
reported = true;
|
|
148
|
-
logged(house.deliver('/kit/idle', {}, idle));
|
|
154
|
+
logged(house.deliver('/kit/kits/report-idle', {}, idle));
|
|
149
155
|
}
|
|
150
156
|
};
|
|
151
157
|
const calls = new Calls(house, changed);
|
|
@@ -154,50 +160,59 @@ export async function resident() {
|
|
|
154
160
|
agents,
|
|
155
161
|
copies,
|
|
156
162
|
calls,
|
|
157
|
-
send: (
|
|
163
|
+
send: (oneWayCall) => connection?.send(oneWayCall) ?? false,
|
|
158
164
|
changed,
|
|
159
165
|
});
|
|
160
166
|
const signIns = new SignIns(house, agents, calls);
|
|
161
167
|
const update = new KitUpdate(calls);
|
|
162
|
-
|
|
168
|
+
if (process.env.HOUSE_KIT_SANDBOX !== '1')
|
|
169
|
+
takeUnservedRelease((release) => logged(update.takeRefused(release)));
|
|
170
|
+
removeInputs();
|
|
171
|
+
const scripts = new Scripts(calls, (oneWayCall) => connection?.send(oneWayCall) ?? false);
|
|
163
172
|
for (const signal of ['SIGTERM', 'SIGINT']) {
|
|
164
173
|
process.once(signal, () => {
|
|
165
|
-
|
|
166
|
-
|
|
174
|
+
void stop(() => {
|
|
175
|
+
removeInputs();
|
|
176
|
+
process.kill(process.pid, signal);
|
|
177
|
+
});
|
|
167
178
|
});
|
|
168
179
|
}
|
|
169
|
-
|
|
170
|
-
|
|
180
|
+
const unenrolled = () => {
|
|
181
|
+
if (!enrolled())
|
|
182
|
+
void stop(() => process.exit(1));
|
|
183
|
+
};
|
|
184
|
+
watch(kitHome(), unenrolled);
|
|
185
|
+
unenrolled();
|
|
186
|
+
await house.deliver('/kit/kits/report-restart', {}).catch(report);
|
|
171
187
|
logged(agents.refresh());
|
|
188
|
+
agents.keepCurrent(() => process.env.HOUSE_KIT_SANDBOX === '1' && reported);
|
|
172
189
|
connection = holdConnection({
|
|
173
190
|
opened: () => {
|
|
174
191
|
conversations.opened();
|
|
175
192
|
changed();
|
|
176
193
|
logged(copies.connected());
|
|
177
194
|
},
|
|
178
|
-
closed: () =>
|
|
195
|
+
closed: () => scripts.disconnected(),
|
|
179
196
|
call: (call) => {
|
|
180
197
|
if (call.kind === 'sign_in')
|
|
181
198
|
signIns.start(call);
|
|
182
199
|
else if (call.kind === 'update')
|
|
183
|
-
update.
|
|
184
|
-
else if (call.kind === 'run_wizard')
|
|
185
|
-
|
|
200
|
+
update.take(call);
|
|
201
|
+
else if (call.kind === 'run_wizard' || call.kind === 'run_function')
|
|
202
|
+
scripts.start(call);
|
|
186
203
|
else if (CONVERSATION_METHODS.has(call.kind))
|
|
187
204
|
conversations.call(call);
|
|
188
205
|
else {
|
|
189
|
-
const refused = { refused:
|
|
206
|
+
const refused = { refused: unknownMethod(call.kind) };
|
|
190
207
|
void calls.carry(call.input_id, async () => ({ result: refused }));
|
|
191
208
|
}
|
|
192
209
|
},
|
|
193
|
-
|
|
194
|
-
if (
|
|
195
|
-
conversations.watching(
|
|
196
|
-
if (
|
|
197
|
-
logged(copies.changed(notification.rooms));
|
|
198
|
-
if (notification.type === 'work_available' && notification.subject === 'agents')
|
|
210
|
+
oneWayCall: (oneWayCall) => {
|
|
211
|
+
if (oneWayCall.type === 'watching')
|
|
212
|
+
conversations.watching(oneWayCall.watching === true);
|
|
213
|
+
if (oneWayCall.type === 'work_available' && oneWayCall.subject === 'agents')
|
|
199
214
|
logged(agents.refresh());
|
|
200
|
-
|
|
215
|
+
scripts.notified(oneWayCall);
|
|
201
216
|
},
|
|
202
217
|
});
|
|
203
218
|
}
|
package/dist/scope.js
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { execFileSync } from 'node:child_process';
|
|
2
|
-
import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
|
|
2
|
+
import { mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
|
|
3
3
|
import { join } from 'node:path';
|
|
4
4
|
const LISTING_BYTES = 1 << 28;
|
|
5
5
|
const CGROUPS = '/sys/fs/cgroup';
|
|
@@ -122,15 +122,23 @@ function members(group) {
|
|
|
122
122
|
}
|
|
123
123
|
return pids;
|
|
124
124
|
}
|
|
125
|
+
function besideCli(cli) {
|
|
126
|
+
try {
|
|
127
|
+
return `${realpathSync(cli)}-`;
|
|
128
|
+
}
|
|
129
|
+
catch {
|
|
130
|
+
return null;
|
|
131
|
+
}
|
|
132
|
+
}
|
|
125
133
|
export class Scope {
|
|
126
134
|
marker;
|
|
127
|
-
|
|
135
|
+
helpers;
|
|
128
136
|
group;
|
|
129
137
|
session = null;
|
|
130
138
|
recorded = null;
|
|
131
139
|
constructor(marker, name, cli) {
|
|
132
140
|
this.marker = marker;
|
|
133
|
-
this.
|
|
141
|
+
this.helpers = besideCli(cli);
|
|
134
142
|
const own = ownGroup();
|
|
135
143
|
this.group = own === null ? null : join(own, name);
|
|
136
144
|
try {
|
|
@@ -168,7 +176,7 @@ export class Scope {
|
|
|
168
176
|
return true;
|
|
169
177
|
if (this.recorded === null)
|
|
170
178
|
return found.size > 0;
|
|
171
|
-
return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || command.startsWith(
|
|
179
|
+
return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || (this.helpers !== null && command.startsWith(this.helpers))));
|
|
172
180
|
}
|
|
173
181
|
empty() {
|
|
174
182
|
return this.found()?.size === 0;
|
package/dist/scripts.js
ADDED
|
@@ -0,0 +1,255 @@
|
|
|
1
|
+
import { spawn as spawnPiped } from 'node:child_process';
|
|
2
|
+
import { randomUUID } from 'node:crypto';
|
|
3
|
+
import { once } from 'node:events';
|
|
4
|
+
import { rmSync } from 'node:fs';
|
|
5
|
+
import { mkdir, rm, writeFile } from 'node:fs/promises';
|
|
6
|
+
import { constants } from 'node:os';
|
|
7
|
+
import { join } from 'node:path';
|
|
8
|
+
import { loginPath, onLoginPath } from './clis.js';
|
|
9
|
+
import { kitHome } from './home.js';
|
|
10
|
+
import { childEnvironment } from './relay.js';
|
|
11
|
+
import { killTree } from './scope.js';
|
|
12
|
+
const TERMINAL = 'xterm-256color';
|
|
13
|
+
const FIRST_SIZE = { cols: 80, rows: 24 };
|
|
14
|
+
const SIGNALLED = 128;
|
|
15
|
+
const NEWLINE = 0x0a;
|
|
16
|
+
const NO_BASH = "bash is not on the login shell's PATH";
|
|
17
|
+
const LOST = { refused: 'the Kit lost its connection to House' };
|
|
18
|
+
function causeOf(error) {
|
|
19
|
+
return error instanceof Error ? error.message : String(error);
|
|
20
|
+
}
|
|
21
|
+
function failed(plan, cause) {
|
|
22
|
+
process.stderr.write(`kit: ${plan.named} could not start: ${cause}\n`);
|
|
23
|
+
return { refused: `the script could not start: ${cause}` };
|
|
24
|
+
}
|
|
25
|
+
function planned(call) {
|
|
26
|
+
if (call.kind === 'run_wizard')
|
|
27
|
+
return { named: 'a Web Wizard', script: call.script, terminal: 'page', function: null };
|
|
28
|
+
return {
|
|
29
|
+
named: 'an Environment function',
|
|
30
|
+
script: call.script,
|
|
31
|
+
terminal: call.terminal ? 'at once' : null,
|
|
32
|
+
function: { input: call.input, timeCap: call.time_cap, outputCap: call.output_cap },
|
|
33
|
+
};
|
|
34
|
+
}
|
|
35
|
+
function inputs() {
|
|
36
|
+
return join(kitHome(), 'inputs');
|
|
37
|
+
}
|
|
38
|
+
async function inputFile(value) {
|
|
39
|
+
await mkdir(inputs(), { recursive: true, mode: 0o700 });
|
|
40
|
+
const path = join(inputs(), `${randomUUID()}.json`);
|
|
41
|
+
await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
|
|
42
|
+
return path;
|
|
43
|
+
}
|
|
44
|
+
export function removeInputs() {
|
|
45
|
+
rmSync(inputs(), { recursive: true, force: true });
|
|
46
|
+
}
|
|
47
|
+
function struck(line, typed) {
|
|
48
|
+
return typed.some((typedLine) => line.includes(typedLine));
|
|
49
|
+
}
|
|
50
|
+
class KeptOutput {
|
|
51
|
+
cap;
|
|
52
|
+
typedText = '';
|
|
53
|
+
text = '';
|
|
54
|
+
bytes = 0;
|
|
55
|
+
line = '';
|
|
56
|
+
lineBytes = 0;
|
|
57
|
+
dropping = false;
|
|
58
|
+
cut = false;
|
|
59
|
+
constructor(cap) {
|
|
60
|
+
this.cap = cap;
|
|
61
|
+
}
|
|
62
|
+
typed(data) {
|
|
63
|
+
this.typedText += data;
|
|
64
|
+
}
|
|
65
|
+
add(data) {
|
|
66
|
+
const pieces = data.split('\n');
|
|
67
|
+
const rest = pieces.pop();
|
|
68
|
+
for (const piece of pieces)
|
|
69
|
+
this.ended(piece);
|
|
70
|
+
this.extend(rest);
|
|
71
|
+
}
|
|
72
|
+
kept() {
|
|
73
|
+
const typed = this.typedLines(true);
|
|
74
|
+
this.text = [...this.text.split(/(?<=\n)/), this.line].filter((line) => line !== '' && !struck(line, typed)).join('');
|
|
75
|
+
this.bytes = Buffer.byteLength(this.text);
|
|
76
|
+
this.trim();
|
|
77
|
+
return { output: this.text, cut: this.cut };
|
|
78
|
+
}
|
|
79
|
+
typedLines(all) {
|
|
80
|
+
const lines = this.typedText.split(/\r\n|\r|\n/);
|
|
81
|
+
if (!all)
|
|
82
|
+
lines.pop();
|
|
83
|
+
return lines.filter((line) => line !== '');
|
|
84
|
+
}
|
|
85
|
+
ended(piece) {
|
|
86
|
+
const line = `${this.line}${piece}\n`;
|
|
87
|
+
const dropped = this.dropping;
|
|
88
|
+
this.line = '';
|
|
89
|
+
this.lineBytes = 0;
|
|
90
|
+
this.dropping = false;
|
|
91
|
+
if (dropped || struck(line, this.typedLines(false)))
|
|
92
|
+
return;
|
|
93
|
+
this.text += line;
|
|
94
|
+
this.bytes += Buffer.byteLength(line);
|
|
95
|
+
if (this.bytes > 2 * this.cap)
|
|
96
|
+
this.trim();
|
|
97
|
+
}
|
|
98
|
+
extend(piece) {
|
|
99
|
+
if (this.dropping)
|
|
100
|
+
return;
|
|
101
|
+
this.line += piece;
|
|
102
|
+
this.lineBytes += Buffer.byteLength(piece);
|
|
103
|
+
if (this.lineBytes <= this.cap)
|
|
104
|
+
return;
|
|
105
|
+
this.text = '';
|
|
106
|
+
this.bytes = 0;
|
|
107
|
+
this.line = '';
|
|
108
|
+
this.lineBytes = 0;
|
|
109
|
+
this.dropping = true;
|
|
110
|
+
this.cut = true;
|
|
111
|
+
}
|
|
112
|
+
trim() {
|
|
113
|
+
if (this.bytes <= this.cap)
|
|
114
|
+
return;
|
|
115
|
+
const bytes = Buffer.from(this.text);
|
|
116
|
+
const start = bytes.indexOf(NEWLINE, bytes.length - this.cap - 1) + 1;
|
|
117
|
+
this.text = bytes.subarray(start).toString('utf8');
|
|
118
|
+
this.bytes = bytes.length - start;
|
|
119
|
+
this.cut = true;
|
|
120
|
+
}
|
|
121
|
+
}
|
|
122
|
+
export class Scripts {
|
|
123
|
+
calls;
|
|
124
|
+
send;
|
|
125
|
+
runs = new Map();
|
|
126
|
+
constructor(calls, send) {
|
|
127
|
+
this.calls = calls;
|
|
128
|
+
this.send = send;
|
|
129
|
+
}
|
|
130
|
+
start(call) {
|
|
131
|
+
void this.calls.carry(call.input_id, () => this.run(call.input_id, planned(call)));
|
|
132
|
+
}
|
|
133
|
+
notified(oneWayCall) {
|
|
134
|
+
const run = this.runs.get(String(oneWayCall.wizard));
|
|
135
|
+
if (run === undefined)
|
|
136
|
+
return;
|
|
137
|
+
if (oneWayCall.type === 'wizard_input')
|
|
138
|
+
this.typed(run, String(oneWayCall.data));
|
|
139
|
+
if (oneWayCall.type === 'wizard_size')
|
|
140
|
+
this.resized(run, { cols: Number(oneWayCall.cols), rows: Number(oneWayCall.rows) });
|
|
141
|
+
if (oneWayCall.type === 'wizard_end' && run.plan.terminal === 'page')
|
|
142
|
+
this.end(run, {});
|
|
143
|
+
}
|
|
144
|
+
disconnected() {
|
|
145
|
+
for (const run of this.runs.values())
|
|
146
|
+
this.end(run, LOST);
|
|
147
|
+
}
|
|
148
|
+
async run(id, plan) {
|
|
149
|
+
const size = plan.terminal === 'page' ? null : FIRST_SIZE;
|
|
150
|
+
const output = plan.function === null ? null : new KeptOutput(plan.function.outputCap);
|
|
151
|
+
const run = { plan, input: null, output, process: null, pipes: [], terminal: null, size, typed: [], ended: null, sized: Promise.withResolvers() };
|
|
152
|
+
if (size !== null)
|
|
153
|
+
run.sized.resolve();
|
|
154
|
+
this.runs.set(id, run);
|
|
155
|
+
try {
|
|
156
|
+
return { result: await this.ran(id, run), release: plan.function !== null };
|
|
157
|
+
}
|
|
158
|
+
finally {
|
|
159
|
+
this.runs.delete(id);
|
|
160
|
+
if (run.input !== null)
|
|
161
|
+
await rm(run.input, { force: true });
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
async ran(id, run) {
|
|
165
|
+
const { plan, output } = run;
|
|
166
|
+
let exited;
|
|
167
|
+
try {
|
|
168
|
+
const { spawn } = await import('@lydell/node-pty');
|
|
169
|
+
const shell = await onLoginPath('bash');
|
|
170
|
+
if (shell === null)
|
|
171
|
+
return failed(plan, NO_BASH);
|
|
172
|
+
const path = await loginPath();
|
|
173
|
+
await run.sized.promise;
|
|
174
|
+
if (plan.function !== null)
|
|
175
|
+
run.input = await inputFile(plan.function.input);
|
|
176
|
+
if (run.ended !== null)
|
|
177
|
+
return run.ended;
|
|
178
|
+
const environment = { ...childEnvironment(), PATH: path, ...(run.input === null ? {} : { HOUSE_INPUT: run.input }) };
|
|
179
|
+
if (plan.terminal === null) {
|
|
180
|
+
({ exited } = await this.piped(plan.script, shell, environment, run));
|
|
181
|
+
}
|
|
182
|
+
else {
|
|
183
|
+
const terminal = spawn(shell, ['-c', plan.script], { name: TERMINAL, ...run.size, cwd: process.cwd(), env: environment });
|
|
184
|
+
run.process = terminal;
|
|
185
|
+
run.terminal = terminal;
|
|
186
|
+
terminal.onData((data) => {
|
|
187
|
+
this.send({ type: 'wizard_output', wizard: id, data });
|
|
188
|
+
output?.add(data);
|
|
189
|
+
});
|
|
190
|
+
for (const data of run.typed.splice(0))
|
|
191
|
+
terminal.write(data);
|
|
192
|
+
exited = new Promise((resolve) => terminal.onExit(({ exitCode, signal }) => resolve(signal ? SIGNALLED + signal : exitCode)));
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
catch (error) {
|
|
196
|
+
return failed(plan, causeOf(error));
|
|
197
|
+
}
|
|
198
|
+
let timedOut = false;
|
|
199
|
+
// House sends a function run's time cap in seconds, and a run still going at its cap ends with its process group and the output pipes it holds.
|
|
200
|
+
const capped = plan.function === null ? undefined : setTimeout(() => {
|
|
201
|
+
timedOut = true;
|
|
202
|
+
this.stop(run);
|
|
203
|
+
}, plan.function.timeCap * 1000);
|
|
204
|
+
const code = await exited;
|
|
205
|
+
clearTimeout(capped);
|
|
206
|
+
if (run.ended !== null)
|
|
207
|
+
return run.ended;
|
|
208
|
+
if (output === null)
|
|
209
|
+
return { exit_code: code };
|
|
210
|
+
const kept = output.kept();
|
|
211
|
+
return timedOut ? { timed_out: true, ...kept } : { exit_code: code, ...kept };
|
|
212
|
+
}
|
|
213
|
+
async piped(script, shell, environment, run) {
|
|
214
|
+
const child = spawnPiped(shell, ['-c', script], { cwd: process.cwd(), env: environment, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
|
|
215
|
+
const exited = new Promise((resolve) => child.once('close', (code, signal) => resolve(signal === null ? code : SIGNALLED + constants.signals[signal])));
|
|
216
|
+
await once(child, 'spawn');
|
|
217
|
+
run.process = { pid: child.pid };
|
|
218
|
+
run.pipes = [child.stdout, child.stderr];
|
|
219
|
+
for (const pipe of run.pipes) {
|
|
220
|
+
pipe.setEncoding('utf8');
|
|
221
|
+
pipe.on('data', (data) => run.output.add(data));
|
|
222
|
+
}
|
|
223
|
+
if (run.ended !== null)
|
|
224
|
+
this.stop(run);
|
|
225
|
+
return { exited };
|
|
226
|
+
}
|
|
227
|
+
typed(run, data) {
|
|
228
|
+
run.output?.typed(data);
|
|
229
|
+
if (run.terminal === null)
|
|
230
|
+
run.typed.push(data);
|
|
231
|
+
else
|
|
232
|
+
run.terminal.write(data);
|
|
233
|
+
}
|
|
234
|
+
resized(run, size) {
|
|
235
|
+
run.size = size;
|
|
236
|
+
run.sized.resolve();
|
|
237
|
+
try {
|
|
238
|
+
run.terminal?.resize(size.cols, size.rows);
|
|
239
|
+
}
|
|
240
|
+
catch { }
|
|
241
|
+
}
|
|
242
|
+
end(run, result) {
|
|
243
|
+
if (run.ended !== null)
|
|
244
|
+
return;
|
|
245
|
+
run.ended = result;
|
|
246
|
+
run.sized.resolve();
|
|
247
|
+
this.stop(run);
|
|
248
|
+
}
|
|
249
|
+
stop(run) {
|
|
250
|
+
if (run.process !== null)
|
|
251
|
+
killTree(run.process);
|
|
252
|
+
for (const pipe of run.pipes)
|
|
253
|
+
pipe.destroy();
|
|
254
|
+
}
|
|
255
|
+
}
|
package/dist/secret-input.js
CHANGED
|
@@ -2,7 +2,7 @@ import { finalRefusal, retryDelay } from './api.js';
|
|
|
2
2
|
export async function holdSecretInput(house, subject, steps, waiting) {
|
|
3
3
|
for (let failures = 0; waiting();) {
|
|
4
4
|
try {
|
|
5
|
-
const held = await house.post(
|
|
5
|
+
const held = await house.post('/kit/secret-inputs/await', { subject, steps });
|
|
6
6
|
if (held.outcome === 'collected')
|
|
7
7
|
return held.content;
|
|
8
8
|
if (held.release !== 'held')
|
package/dist/sign-in.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { spawn } from 'node:child_process';
|
|
2
2
|
import { createInterface } from 'node:readline';
|
|
3
|
-
import { CLIS
|
|
3
|
+
import { CLIS } from './clis.js';
|
|
4
|
+
import { childEnvironment } from './relay.js';
|
|
4
5
|
import { killTree } from './scope.js';
|
|
5
6
|
import { holdSecretInput } from './secret-input.js';
|
|
6
7
|
const ESCAPE = /\u001b\[[\d;]*m/g;
|
|
@@ -56,7 +57,7 @@ export class SignIns {
|
|
|
56
57
|
const child = spawn(cli, login.args, {
|
|
57
58
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
58
59
|
detached: true,
|
|
59
|
-
env:
|
|
60
|
+
env: childEnvironment(),
|
|
60
61
|
});
|
|
61
62
|
const running = () => child.exitCode === null && child.signalCode === null;
|
|
62
63
|
const stop = () => killTree(child);
|
package/dist/silence.js
ADDED
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
const SYSTEM_CLOCK = {
|
|
2
|
+
later: (delay, callback) => setTimeout(callback, delay),
|
|
3
|
+
clear: (timer) => clearTimeout(timer),
|
|
4
|
+
};
|
|
5
|
+
export class Silence {
|
|
6
|
+
timer = null;
|
|
7
|
+
interval;
|
|
8
|
+
silent;
|
|
9
|
+
clock;
|
|
10
|
+
constructor(interval, silent, clock = SYSTEM_CLOCK) {
|
|
11
|
+
this.interval = interval;
|
|
12
|
+
this.silent = silent;
|
|
13
|
+
this.clock = clock;
|
|
14
|
+
}
|
|
15
|
+
heard() {
|
|
16
|
+
this.stop();
|
|
17
|
+
this.timer = this.clock.later(this.interval, () => {
|
|
18
|
+
this.timer = null;
|
|
19
|
+
this.silent();
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
stop() {
|
|
23
|
+
if (this.timer === null)
|
|
24
|
+
return;
|
|
25
|
+
this.clock.clear(this.timer);
|
|
26
|
+
this.timer = null;
|
|
27
|
+
}
|
|
28
|
+
}
|
package/dist/skills.js
CHANGED
|
@@ -1,10 +1,14 @@
|
|
|
1
|
-
import { cp, lstat, mkdir, realpath, rm, symlink } from 'node:fs/promises';
|
|
1
|
+
import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
|
|
2
2
|
import { homedir } from 'node:os';
|
|
3
3
|
import { join, relative } from 'node:path';
|
|
4
|
-
import { listSkills } from '@agentshouse/skills';
|
|
4
|
+
import { GUIDE, listSkills } from '@agentshouse/skills';
|
|
5
|
+
import { parse } from 'yaml';
|
|
5
6
|
import { KIT_RELEASE } from './clis.js';
|
|
6
7
|
import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
|
|
7
8
|
const RECORD = 'skill-set.json';
|
|
9
|
+
const ENTRY = 'SKILL.md';
|
|
10
|
+
const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
|
|
11
|
+
const ORIGIN = '<origin>';
|
|
8
12
|
function skillsDirectory() {
|
|
9
13
|
return join(homedir(), '.agents', 'skills');
|
|
10
14
|
}
|
|
@@ -22,9 +26,31 @@ async function present(path) {
|
|
|
22
26
|
throw error;
|
|
23
27
|
}
|
|
24
28
|
}
|
|
25
|
-
|
|
29
|
+
function skillName(text) {
|
|
30
|
+
const front = FRONTMATTER.exec(text);
|
|
31
|
+
const fields = (front === null ? null : parse(front[1]));
|
|
32
|
+
return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
|
|
33
|
+
}
|
|
34
|
+
function skillSet(origin) {
|
|
35
|
+
const upstream = listSkills().map(({ name, directory }) => ({
|
|
36
|
+
name,
|
|
37
|
+
place: (destination) => cp(directory, destination, { recursive: true }),
|
|
38
|
+
}));
|
|
39
|
+
const pages = GUIDE.flatMap(({ text }) => {
|
|
40
|
+
const name = skillName(text);
|
|
41
|
+
if (name === undefined)
|
|
42
|
+
return [];
|
|
43
|
+
const place = async (destination) => {
|
|
44
|
+
await mkdir(destination);
|
|
45
|
+
await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
|
|
46
|
+
};
|
|
47
|
+
return [{ name, place }];
|
|
48
|
+
});
|
|
49
|
+
return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
|
|
50
|
+
}
|
|
51
|
+
async function install(origin) {
|
|
26
52
|
const placed = [];
|
|
27
|
-
for (const skill of
|
|
53
|
+
for (const skill of skillSet(origin)) {
|
|
28
54
|
if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
|
|
29
55
|
placed.push(skill);
|
|
30
56
|
}
|
|
@@ -35,32 +61,32 @@ async function install() {
|
|
|
35
61
|
await mkdir(claudeDirectory(), { recursive: true });
|
|
36
62
|
const skills = await realpath(skillsDirectory());
|
|
37
63
|
const claude = await realpath(claudeDirectory());
|
|
38
|
-
for (const { name,
|
|
39
|
-
await
|
|
64
|
+
for (const { name, place } of placed) {
|
|
65
|
+
await place(join(skillsDirectory(), name));
|
|
40
66
|
if (claude !== skills)
|
|
41
67
|
await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
|
|
42
68
|
}
|
|
43
|
-
await writeHome(RECORD, { version: KIT_RELEASE, names });
|
|
69
|
+
await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
|
|
44
70
|
}
|
|
45
|
-
export async function placeSkillSet() {
|
|
71
|
+
export async function placeSkillSet(origin) {
|
|
46
72
|
try {
|
|
47
|
-
await replaceSkillSet();
|
|
73
|
+
await replaceSkillSet(origin);
|
|
48
74
|
}
|
|
49
75
|
catch (error) {
|
|
50
76
|
process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
|
|
51
77
|
}
|
|
52
78
|
}
|
|
53
|
-
async function replaceSkillSet() {
|
|
79
|
+
async function replaceSkillSet(origin) {
|
|
54
80
|
const accepted = (await readConfiguration()).skills;
|
|
55
81
|
const installed = await readHome(RECORD);
|
|
56
|
-
if (accepted && installed?.version === KIT_RELEASE)
|
|
82
|
+
if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
|
|
57
83
|
return;
|
|
58
84
|
for (const name of installed?.names ?? []) {
|
|
59
85
|
await rm(join(claudeDirectory(), name), { recursive: true, force: true });
|
|
60
86
|
await rm(join(skillsDirectory(), name), { recursive: true, force: true });
|
|
61
87
|
}
|
|
62
88
|
if (accepted)
|
|
63
|
-
await install();
|
|
89
|
+
await install(origin);
|
|
64
90
|
else
|
|
65
91
|
await rm(join(kitHome(), RECORD), { force: true });
|
|
66
92
|
}
|