@instruction.md/agents 0.0.0-stage → 0.1.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/LICENSE +21 -0
- package/NOTICE +73 -0
- package/README.md +204 -2
- package/dist/accounts.js +327 -0
- package/dist/acp.js +268 -0
- package/dist/agent.d.ts +60 -0
- package/dist/agent.js +86 -0
- package/dist/apply.js +392 -0
- package/dist/connect.js +138 -0
- package/dist/converse.js +229 -0
- package/dist/fleet.js +1000 -0
- package/dist/hook.js +406 -0
- package/dist/hosts.js +151 -0
- package/dist/main.js +119 -0
- package/dist/oauth.js +374 -0
- package/dist/pi.d.ts +59 -0
- package/dist/pi.js +89 -0
- package/dist/setup.js +324 -0
- package/dist/sync.js +114 -0
- package/dist/turns.js +143 -0
- package/package.json +70 -3
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 TSOK Inc.
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/NOTICE
ADDED
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
instruction.md
|
|
2
|
+
Copyright (c) 2026 TSOK Inc.
|
|
3
|
+
|
|
4
|
+
This package is licensed under the MIT License (see LICENSE). The repository it
|
|
5
|
+
is built from is licensed differently; a repository licence does not travel in
|
|
6
|
+
a published package, which is why this file exists.
|
|
7
|
+
|
|
8
|
+
This package additionally redistributes material from the Instruction
|
|
9
|
+
Specification, under different licences:
|
|
10
|
+
|
|
11
|
+
The instruction.md specification's registry and schemas
|
|
12
|
+
(`dist/spec/specification/registry.json`, `dist/spec/specification/instruction.schema.json`,
|
|
13
|
+
`dist/spec/specification/schemas/`, `dist/spec/specification/samples/`, verbatim; the registry
|
|
14
|
+
is also inlined, unchanged, in `dist/spec/registry.js`)
|
|
15
|
+
Source: https://github.com/instruction-md/specification
|
|
16
|
+
Licence: Creative Commons Attribution 4.0 International (CC BY 4.0)
|
|
17
|
+
https://creativecommons.org/licenses/by/4.0/
|
|
18
|
+
Author: instruction.md (TSOK Inc.)
|
|
19
|
+
Changes: none; redistributed verbatim.
|
|
20
|
+
|
|
21
|
+
Its conformance vectors (`dist/spec/specification/conformance/`, verbatim)
|
|
22
|
+
Source: https://github.com/instruction-md/specification
|
|
23
|
+
Licence: Apache License 2.0 (`dist/spec/specification/conformance/LICENSE`)
|
|
24
|
+
Changes: none; redistributed verbatim.
|
|
25
|
+
|
|
26
|
+
CC BY 4.0 requires attribution, and attribution has to arrive with the copy.
|
|
27
|
+
|
|
28
|
+
It also redistributes eleven icons from Lucide, embedded in the renderer's
|
|
29
|
+
dist/render/icons.js (LUCIDE):
|
|
30
|
+
circle-check, circle-arrow-right, ban, circle-plus, circle-dot, circle-minus,
|
|
31
|
+
shield, info, lightbulb, triangle-alert and star — the rules', the guardrail's and
|
|
32
|
+
the alerts' icons, the same as the instruction.md studio draws.
|
|
33
|
+
|
|
34
|
+
Lucide (lucide 1.49.0)
|
|
35
|
+
Source: https://lucide.dev — https://github.com/lucide-icons/lucide
|
|
36
|
+
Licence: ISC License
|
|
37
|
+
|
|
38
|
+
Copyright (c) 2026 Lucide Icons and Contributors
|
|
39
|
+
|
|
40
|
+
Permission to use, copy, modify, and/or distribute this software for any
|
|
41
|
+
purpose with or without fee is hereby granted, provided that the above
|
|
42
|
+
copyright notice and this permission notice appear in all copies.
|
|
43
|
+
|
|
44
|
+
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
45
|
+
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
46
|
+
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
47
|
+
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
48
|
+
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
49
|
+
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
50
|
+
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
51
|
+
|
|
52
|
+
Some of them (circle-plus, circle-minus, info, triangle-alert, star) derive
|
|
53
|
+
from the Feather project:
|
|
54
|
+
|
|
55
|
+
The MIT License (MIT) — Copyright (c) 2013-present Cole Bemis
|
|
56
|
+
|
|
57
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
58
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
59
|
+
in the Software without restriction, including without limitation the rights
|
|
60
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
61
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
62
|
+
furnished to do so, subject to the following conditions:
|
|
63
|
+
|
|
64
|
+
The above copyright notice and this permission notice shall be included in all
|
|
65
|
+
copies or substantial portions of the Software.
|
|
66
|
+
|
|
67
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
68
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
69
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
70
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
71
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
72
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
73
|
+
SOFTWARE.
|
package/README.md
CHANGED
|
@@ -1,3 +1,205 @@
|
|
|
1
|
-
#
|
|
1
|
+
# @instruction.md/agents
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Run agents with [instruction.md](https://instruction.md): the `instruction-agents` CLI, for Node 18+.
|
|
4
|
+
|
|
5
|
+
- **Following an instruction**: the hooks that give Claude Code, Codex and a dozen other coding agents the instruction a
|
|
6
|
+
project follows at a session's start, and each new version at the next prompt; the ACP proxy, pi's extension, Amp's
|
|
7
|
+
turns, and `follow()` for an agent you run with an SDK.
|
|
8
|
+
- **Running agents**: `fleet`, an agent for every deployment of a rule, each in a folder of its own. Its questions and
|
|
9
|
+
permission requests reach you on [instruction.md/agents](https://instruction.md/agents/), and what you write reaches it.
|
|
10
|
+
- **An agent's servers, skills and sign-ins**: `apply`, `doctor`, `accounts`, `signin`, `credential`. Keys stay on the
|
|
11
|
+
machine or in your organization's own secret store.
|
|
12
|
+
|
|
13
|
+
Writing, checking and releasing instructions is the `instruction` command, in the
|
|
14
|
+
[instruction.md](https://www.npmjs.com/package/instruction.md) package this one is built on.
|
|
15
|
+
|
|
16
|
+
```sh
|
|
17
|
+
npm install -g @instruction.md/agents
|
|
18
|
+
instruction-agents login # the same sign-in as `instruction login`
|
|
19
|
+
instruction-agents connect --host claude-code acme/support@stable --with-hooks --write
|
|
20
|
+
instruction-agents fleet --platform laptop --org acme -- claude -p "Work through today's queue."
|
|
21
|
+
```
|
|
22
|
+
|
|
23
|
+
or, without installing, `npx -y @instruction.md/agents <command>`. `instruction-agents --help` lists every command.
|
|
24
|
+
Until 0.10.0 these were `instruction` commands; `instruction hook`, `instruction fleet` and the rest still work and hand
|
|
25
|
+
over to this package, so hook settings a project committed keep working.
|
|
26
|
+
|
|
27
|
+
## A project's instruction in Claude Code and Codex: `instruction-agents hook`
|
|
28
|
+
|
|
29
|
+
A project names the instruction it follows in `.instruction/follow.json`, and each coding agent's hooks run
|
|
30
|
+
`instruction-agents hook`: every session starts with the instruction, and a session already running gets a new version at its
|
|
31
|
+
next prompt. One command sets it up:
|
|
32
|
+
|
|
33
|
+
```
|
|
34
|
+
npx -y @instruction.md/agents connect --host claude-code acme/support@stable --with-hooks --write # .claude/settings.json
|
|
35
|
+
npx -y @instruction.md/agents connect --host codex acme/support@stable --with-hooks --write # .codex/hooks.json
|
|
36
|
+
```
|
|
37
|
+
|
|
38
|
+
It writes (merged into what is there, never overwriting a file it can't read):
|
|
39
|
+
|
|
40
|
+
- `.instruction/follow.json` — commit it: `{ "follow": "instruction://acme/support@stable" }`, with
|
|
41
|
+
`requireSignature`, `keys` (a publisher key file), `url`, `refreshSeconds` (60) and `maxInjectChars` (9000) if
|
|
42
|
+
you want them;
|
|
43
|
+
- `.instruction/.gitignore` — `current.md` and `state.json`, the fetched text and its state, stay out of the repository;
|
|
44
|
+
- the hooks: `SessionStart` and `UserPromptSubmit` running `npx -y @instruction.md/agents hook claude-code` (or `codex`).
|
|
45
|
+
|
|
46
|
+
Without `--write` it prints them. What a session sees:
|
|
47
|
+
|
|
48
|
+
- at its start, the whole text (the delivered text, what `instruction deliver` makes) as
|
|
49
|
+
`<instruction uri version digest>…</instruction>`;
|
|
50
|
+
- at a prompt, nothing at all while the instruction is unchanged; after a release,
|
|
51
|
+
`<instruction-update from="v4" to="v5">These instructions replace the earlier version … in full.…</instruction-update>`,
|
|
52
|
+
and a line the person sees: `instruction.md: acme/support v4 → v5 (signature verified)`.
|
|
53
|
+
|
|
54
|
+
The hook reads at most every `refreshSeconds`, within 1.5 s, and otherwise uses the last good copy
|
|
55
|
+
(`.instruction/current.md`): it never holds a prompt up, and exits 0 even offline. A newer version the policy refuses
|
|
56
|
+
(unsigned with `requireSignature`, a refused signature, a revoked version) is held and said once; the last good one
|
|
57
|
+
stays. `--fail-closed` blocks a prompt instead when there is no copy at all. Signed in (`instruction login`, or
|
|
58
|
+
`INSTRUCTION_MD_TOKEN`), it reads over MCP and tells the registry which version each session applied; without a sign-in
|
|
59
|
+
it reads a public instruction over plain HTTP, conditionally. It only reads — the free plan's one live connection stays
|
|
60
|
+
free.
|
|
61
|
+
|
|
62
|
+
Codex also re-reads your own `~/.codex/AGENTS.md` before every model request, so an instruction written there is live
|
|
63
|
+
in every repository; `--block` keeps only its own region of the file:
|
|
64
|
+
|
|
65
|
+
```
|
|
66
|
+
npx -y instruction.md watch acme/me@latest --out ~/.codex/AGENTS.md --block
|
|
67
|
+
```
|
|
68
|
+
|
|
69
|
+
For an organization, `instruction-agents connect --host claude-code|codex <uri> --managed` prints the settings an
|
|
70
|
+
administrator deploys (Claude Code's `managed-settings.json`, Codex's `requirements.toml`): every session on the
|
|
71
|
+
machine follows `<uri>` (`instruction-agents hook <host> --follow <uri>`).
|
|
72
|
+
|
|
73
|
+
`instruction watch` without a URI follows the project's `follow.json` and keeps `.instruction/current.md`;
|
|
74
|
+
`--lines` prints one line per version applied after it started on stdout — not the one it starts on, which the session's
|
|
75
|
+
start hook gave (a Claude Code plugin monitor turns each into a notice that wakes the session; in a project that follows
|
|
76
|
+
nothing, it exits at once and says nothing).
|
|
77
|
+
|
|
78
|
+
A plugin for both hosts bundles all of it — the hooks, this CLI's MCP server, a skill on working with followed
|
|
79
|
+
instructions, and in Claude Code a monitor that tells an idle session about a new version: `plugins/instruction-md`
|
|
80
|
+
in the repository (`claude --plugin-dir plugins/instruction-md`); its marketplace comes with the npm release.
|
|
81
|
+
|
|
82
|
+
## Other coding agents
|
|
83
|
+
|
|
84
|
+
The same hook answers other agents, each in the shape it takes (`instruction-agents hook <host>`), and `connect --with-hooks
|
|
85
|
+
--write` writes each one's file, merged into what is there:
|
|
86
|
+
|
|
87
|
+
| Agent | `--host` | Written | When it gets the text |
|
|
88
|
+
| --- | --- | --- | --- |
|
|
89
|
+
| Gemini CLI | `gemini-cli` | `.gemini/settings.json` | `SessionStart`, a new version at `BeforeAgent`; forgotten at `PreCompress` |
|
|
90
|
+
| Antigravity | `antigravity` | `.agents/hooks.json` | `SessionStart`, a new version at `PreInvocation` |
|
|
91
|
+
| Qwen Code | `qwen-code` | `.qwen/settings.json` | `SessionStart`, a new version at `UserPromptSubmit` |
|
|
92
|
+
| Factory Droid | `droid` | `.factory/hooks.json` | as Claude Code |
|
|
93
|
+
| Devin | `devin` | `.devin/hooks.v1.json` (nothing when `.claude/settings.json` already runs the hook: Devin reads it) | as Claude Code |
|
|
94
|
+
| GitHub Copilot CLI | `copilot` | `.github/hooks/instruction-md.json` | `sessionStart`, a new version after a tool call (under Copilot's 10 KB); forgotten at `preCompact` |
|
|
95
|
+
| Cursor | `cursor` | `.cursor/hooks.json` | `sessionStart`, a new version after a tool call; forgotten at `preCompact` |
|
|
96
|
+
| Cline | `cline` | `.clinerules/hooks/<Event>` scripts | `TaskStart`/`TaskResume`, a new version at a prompt or after a tool call |
|
|
97
|
+
| Crush | `crush` | `.crushrc` (`hook add PostToolUse …`) | after a tool call (Crush gives context nowhere else) |
|
|
98
|
+
| Kiro, Junie | `kiro`, `junie` | — (said how: set in their own screens) | Kiro: plain text at `SessionStart` and `PromptSubmit`; Junie: after a tool call |
|
|
99
|
+
|
|
100
|
+
Gemini CLI and Qwen Code escape `<` and `>` in a hook's text, so there the text goes without tags
|
|
101
|
+
(`--- instruction <uri> v5 (<digest>) ---` … `--- end of the instruction ---`). `instruction-agents hook auto` tells the agent
|
|
102
|
+
from what it was sent and its environment (most of these set Claude Code's variables too). Goose takes no text from a
|
|
103
|
+
hook: `instruction-agents hook goose` keeps `.instruction/current.md` fresh, and `GOOSE_MOIM_MESSAGE_FILE` makes Goose re-read
|
|
104
|
+
it every turn. OpenCode, Kilo Code and Aider follow `.instruction/current.md` the same way, kept by
|
|
105
|
+
`instruction watch --out .instruction/current.md`; `connect --host <agent>` prints the lines. For Cursor, a rule every
|
|
106
|
+
chat applies, kept current:
|
|
107
|
+
|
|
108
|
+
```
|
|
109
|
+
npx -y instruction.md watch acme/support@stable --out .cursor/rules/instruction-md.mdc --rule
|
|
110
|
+
```
|
|
111
|
+
|
|
112
|
+
## As a subagent or a skill: `instruction-agents sync`
|
|
113
|
+
|
|
114
|
+
```sh
|
|
115
|
+
npx @instruction.md/agents sync acme/reviewer@stable --as claude-agent # .claude/agents/reviewer.md
|
|
116
|
+
npx @instruction.md/agents sync acme/release@stable --as claude-skill # .claude/skills/release/SKILL.md
|
|
117
|
+
npx @instruction.md/agents sync acme/release@stable --as codex-skill # .agents/skills/release/SKILL.md
|
|
118
|
+
```
|
|
119
|
+
|
|
120
|
+
The file takes the host's front matter (`name`, `description`, from the instruction's name and description), a line
|
|
121
|
+
saying where it came from (address, version, digest) and the delivered text. Run it again to take a new version: it is
|
|
122
|
+
written whole, or left as it is when nothing changed; both hosts notice a changed subagent or skill within the session.
|
|
123
|
+
A file sync didn't write, or one from another instruction, is left alone unless `--force`. In a project that follows
|
|
124
|
+
an instruction, `instruction-agents sync --as …` with no uri syncs that one, from the cache when you aren't signed in.
|
|
125
|
+
|
|
126
|
+
## In pi, Amp and any ACP agent
|
|
127
|
+
|
|
128
|
+
The same follow (`.instruction/follow.json`, or `INSTRUCTION_MD_FOLLOW=<uri>` for every project), for hosts that run
|
|
129
|
+
code of ours rather than a hook command:
|
|
130
|
+
|
|
131
|
+
- **pi** — this package is a pi package: `pi install npm:@instruction.md/agents` (or `pi -e npm:@instruction.md/agents` for one run).
|
|
132
|
+
Before every run the extension sets the section `instruction` of pi's system prompt to the instruction; pi patches
|
|
133
|
+
only a changed section, so a new version reaches a running session at its next prompt, at system level. Its module is
|
|
134
|
+
`@instruction.md/agents/pi` (`piExtension({ follow, requireSignature, url })` for pi's SDK).
|
|
135
|
+
- **Amp** — `plugins/amp/instruction-md.ts` in the repository, copied into `.amp/plugins/` or `~/.config/amp/plugins/`:
|
|
136
|
+
at a thread's first turn the instruction, a new version at the next prompt. It runs
|
|
137
|
+
`instruction-agents turn amp --session <thread> [--start] --cwd <dir>`, which prints `{ context?, notice? }` or nothing.
|
|
138
|
+
- **Any ACP agent, in Zed, JetBrains or another ACP client** — run the agent through the proxy:
|
|
139
|
+
`npx -y @instruction.md/agents acp -- <agent command…>`. Where the agent takes a client's system prompt
|
|
140
|
+
(`sessionCapabilities.systemPrompt`), a session's system prompt carries the instruction; else its first prompt does.
|
|
141
|
+
After a release, the next prompt starts with the new version. The `instruction mcp` bridge is added to the session's
|
|
142
|
+
MCP servers (`--no-bridge` to leave them alone).
|
|
143
|
+
|
|
144
|
+
Each reports the version a session applied with its host (`pi`, `amp`, `acp`).
|
|
145
|
+
|
|
146
|
+
## An agent per instruction: `instruction-agents fleet`
|
|
147
|
+
|
|
148
|
+
A deployment rule (Settings ▸ Deployments in the editor; Team and above) picks a set of instructions: a project, a
|
|
149
|
+
folder, tags, a list. Each instruction in it becomes a deployment, and `instruction-agents fleet` runs one agent per active
|
|
150
|
+
deployment on a machine:
|
|
151
|
+
|
|
152
|
+
```
|
|
153
|
+
npx -y @instruction.md/agents fleet --rule dpr_… -- claude -p "Work through today's queue." --output-format json
|
|
154
|
+
npx -y @instruction.md/agents fleet --platform laptop --org acme --once -- codex exec "Check the open reviews."
|
|
155
|
+
```
|
|
156
|
+
|
|
157
|
+
- Each agent runs in a folder of its own, `<dir>/<owner>__<name>/` (`--dir`, default `./instruction-fleet`), with a
|
|
158
|
+
`.instruction/follow.json` naming its instruction, so the hooks and plugins already set up for Claude Code, Codex and
|
|
159
|
+
the others follow it there. The command gets `INSTRUCTION_MD_FOLLOW` and `INSTRUCTION_MD_DEPLOYMENT`, and
|
|
160
|
+
`{instruction}`, `{name}` and `{dir}` in it are replaced.
|
|
161
|
+
- It reads the deployments every `--interval` seconds (default 60), and at once when the server announces a change. A
|
|
162
|
+
new deployment starts; a retired one stops (SIGTERM, then SIGKILL after 10 s). When a new version is released, what
|
|
163
|
+
the rule says applies: **live** (the default) leaves the agent running and its hooks take the version at its next
|
|
164
|
+
turn; **restart** restarts it; **approve** keeps it on the approved version until someone approves the new one.
|
|
165
|
+
- It never runs more agents than `--max` or the rule's own limit. Agents waiting for approval aren't started.
|
|
166
|
+
- It reports each agent (running, its version, failed with the last lines it wrote to stderr), so the editor's fleet
|
|
167
|
+
view shows them. `--host APP` names what runs (`claude-code`, `codex`, …).
|
|
168
|
+
- `--once` makes one pass, waits for each command to end, and exits non-zero if one failed (a cron job). `--dry-run`
|
|
169
|
+
prints what it would start and stop, and does nothing. `--restart-on-exit` starts a command that exited again, after a
|
|
170
|
+
growing pause.
|
|
171
|
+
- Ctrl-C (or SIGTERM) stops every agent it started. It keeps `.instruction-fleet.json` in the folder, never deletes a
|
|
172
|
+
folder it didn't make, and with `--clean` (with `--once`) removes the folders it made for deployments that are gone.
|
|
173
|
+
Each agent's output is in its folder's `.instruction/fleet.log`.
|
|
174
|
+
|
|
175
|
+
## In your own agent: `@instruction.md/agents/agent`
|
|
176
|
+
|
|
177
|
+
An agent you run with an SDK, `@instruction.md/agents/agent`: an instruction's delivered text as its instructions, and between
|
|
178
|
+
turns, a new version once it is released. It reads after `refreshSeconds` (60 by default) and holds no live
|
|
179
|
+
connection; a read that fails keeps the version in hand. Neither SDK is a dependency.
|
|
180
|
+
|
|
181
|
+
```ts
|
|
182
|
+
import { follow } from "@instruction.md/agents/agent";
|
|
183
|
+
const ins = await follow("instruction://acme/support@stable", { requireSignature: true }); // INSTRUCTION_MD_TOKEN
|
|
184
|
+
|
|
185
|
+
// Claude Agent SDK: the text in the system prompt, a new version at the next prompt
|
|
186
|
+
import { query } from "@anthropic-ai/claude-agent-sdk";
|
|
187
|
+
for await (const m of query({ prompt, options: {
|
|
188
|
+
systemPrompt: { type: "preset", preset: "claude_code", append: ins.text },
|
|
189
|
+
hooks: { UserPromptSubmit: [{ hooks: [async () => (await ins.changedSinceLastTurn())
|
|
190
|
+
? { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: ins.updateBlock() } } : {}] }] },
|
|
191
|
+
} })) { /* … */ }
|
|
192
|
+
|
|
193
|
+
// Codex SDK: the text as the thread's developer instructions (a new version: the next thread)
|
|
194
|
+
import { Codex } from "@openai/codex-sdk";
|
|
195
|
+
const codex = new Codex({ config: { developer_instructions: ins.text } });
|
|
196
|
+
```
|
|
197
|
+
|
|
198
|
+
`ins.text`, `ins.version`, `ins.digest` and `ins.verified` are the version in hand; `ins.contextBlock()` is the text
|
|
199
|
+
wrapped as a host is given it at a session's start, and `ins.updateBlock()`, after `changedSinceLastTurn()` answered
|
|
200
|
+
true, the block that replaces the earlier version in full.
|
|
201
|
+
|
|
202
|
+
## Licence
|
|
203
|
+
|
|
204
|
+
MIT (`LICENSE`). The specification's data inside the package is CC BY 4.0 and its conformance cases Apache-2.0, and
|
|
205
|
+
the renderer's icons are Lucide's (ISC): `NOTICE` says which files and where they come from.
|
package/dist/accounts.js
ADDED
|
@@ -0,0 +1,327 @@
|
|
|
1
|
+
// src/accounts.ts
|
|
2
|
+
import { spawnSync } from "node:child_process";
|
|
3
|
+
import { readFileSync } from "node:fs";
|
|
4
|
+
import { dirname, join } from "node:path";
|
|
5
|
+
import { configDir, fresh, loadTokens, OAuthError, refresh, saveTokens, signIn, tokensPath, xaaToken } from "./oauth.js";
|
|
6
|
+
import { atomicWrite } from "instruction.md/cli";
|
|
7
|
+
var accountsPath = (env = process.env) => env.INSTRUCTION_MD_ACCOUNTS ?? join(configDir(env), "accounts.json");
|
|
8
|
+
function loadAccounts(path = accountsPath()) {
|
|
9
|
+
let raw;
|
|
10
|
+
try {
|
|
11
|
+
raw = readFileSync(path, "utf8");
|
|
12
|
+
} catch {
|
|
13
|
+
return { servers: {}, hosts: {} };
|
|
14
|
+
}
|
|
15
|
+
let a;
|
|
16
|
+
try {
|
|
17
|
+
a = JSON.parse(raw);
|
|
18
|
+
} catch (e) {
|
|
19
|
+
throw new OAuthError(`${path} is not JSON (${e.message})`, 2);
|
|
20
|
+
}
|
|
21
|
+
return { servers: a.servers ?? {}, hosts: a.hosts ?? {} };
|
|
22
|
+
}
|
|
23
|
+
function saveAccounts(a, path = accountsPath()) {
|
|
24
|
+
atomicWrite(path, `${JSON.stringify(a, null, 2)}
|
|
25
|
+
`, 384);
|
|
26
|
+
}
|
|
27
|
+
var keysFor = (id, account) => account ? [`${id}@${account}`, id] : [id];
|
|
28
|
+
function entryFor(a, id, account) {
|
|
29
|
+
for (const key of keysFor(id, account)) if (a.servers[key]) return { key, entry: a.servers[key] };
|
|
30
|
+
return null;
|
|
31
|
+
}
|
|
32
|
+
function describeEntry(e) {
|
|
33
|
+
if (e.env) return `the variable ${e.env}`;
|
|
34
|
+
if (e.command) return `the command ${e.command.split(/\s+/)[0]}…`;
|
|
35
|
+
if (e.oauth) return "a sign-in (instruction-agents signin)";
|
|
36
|
+
if (e.xaa) return `the identity provider ${safeHost(e.xaa.idp)}`;
|
|
37
|
+
return "nothing";
|
|
38
|
+
}
|
|
39
|
+
var safeHost = (u) => {
|
|
40
|
+
try {
|
|
41
|
+
return new URL(u).host;
|
|
42
|
+
} catch {
|
|
43
|
+
return u;
|
|
44
|
+
}
|
|
45
|
+
};
|
|
46
|
+
var SecretError = class extends Error {
|
|
47
|
+
constructor(message, fix) {
|
|
48
|
+
super(message);
|
|
49
|
+
this.fix = fix;
|
|
50
|
+
}
|
|
51
|
+
};
|
|
52
|
+
function secretOf(s, env = process.env) {
|
|
53
|
+
if ("env" in s) {
|
|
54
|
+
const v2 = env[s.env];
|
|
55
|
+
if (!v2?.trim()) throw new SecretError(`the variable ${s.env} isn't set`, `export ${s.env}=…`);
|
|
56
|
+
return v2.trim();
|
|
57
|
+
}
|
|
58
|
+
const shell = process.platform === "win32" ? { cmd: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", s.command] } : { cmd: "/bin/sh", args: ["-c", s.command] };
|
|
59
|
+
const r = spawnSync(shell.cmd, shell.args, { env, encoding: "utf8", timeout: 2e4, maxBuffer: 1 << 20, stdio: ["ignore", "pipe", "pipe"] });
|
|
60
|
+
if (r.error) throw new SecretError(`the command \`${s.command}\` couldn't run (${r.error.message})`);
|
|
61
|
+
if (r.status !== 0) throw new SecretError(`the command \`${s.command}\` failed (exit ${r.status})${r.stderr?.trim() ? `: ${r.stderr.trim().split("\n").slice(-1)[0].slice(0, 200)}` : ""}`);
|
|
62
|
+
const v = (r.stdout ?? "").trim();
|
|
63
|
+
if (!v) throw new SecretError(`the command \`${s.command}\` printed nothing`);
|
|
64
|
+
return v;
|
|
65
|
+
}
|
|
66
|
+
async function headersFor(key, entry, o = {}) {
|
|
67
|
+
const env = o.env ?? process.env, now = o.now ?? Date.now;
|
|
68
|
+
const header = entry.header ?? "Authorization";
|
|
69
|
+
const scheme = entry.scheme ?? "Bearer";
|
|
70
|
+
const put = (v) => ({ [header]: scheme ? `${scheme} ${v}` : v });
|
|
71
|
+
if (entry.env) return put(secretOf({ env: entry.env }, env));
|
|
72
|
+
if (entry.command) return put(secretOf({ command: entry.command }, env));
|
|
73
|
+
if (entry.oauth || entry.xaa) {
|
|
74
|
+
const file = o.tokensFile ?? tokensPath(env);
|
|
75
|
+
const store = loadTokens(file);
|
|
76
|
+
let t = store.tokens[key];
|
|
77
|
+
if (t && !fresh(t, now())) {
|
|
78
|
+
if (t.refresh_token) {
|
|
79
|
+
try {
|
|
80
|
+
t = await refresh(t, o.f, now);
|
|
81
|
+
store.tokens[key] = t;
|
|
82
|
+
saveTokens(store, file);
|
|
83
|
+
} catch (e) {
|
|
84
|
+
if (!entry.xaa) throw new SecretError(`the sign-in to ${key} lapsed and couldn't be renewed (${e.message})`, `instruction-agents signin ${key.split("@")[0]}${key.includes("@") ? ` --account ${key.split("@")[1]}` : ""}${o.url ? ` --url ${o.url}` : ""}`);
|
|
85
|
+
t = void 0;
|
|
86
|
+
}
|
|
87
|
+
} else t = void 0;
|
|
88
|
+
}
|
|
89
|
+
if (!t && entry.xaa) {
|
|
90
|
+
const x = entry.xaa, url = o.url ?? store.tokens[key]?.resource;
|
|
91
|
+
if (!url) throw new SecretError(`the address of ${key} isn't known here`, `instruction-agents credential ${key} --url <its address>`);
|
|
92
|
+
const client = (id, s) => ({ client_id: id, ...s ? { client_secret: secretOf(s, env) } : {} });
|
|
93
|
+
try {
|
|
94
|
+
t = await xaaToken({ idp: x.idp, idpClient: client(x.clientId, x.clientSecret), subjectToken: secretOf(x.subjectToken, env), ...x.subjectTokenType ? { subjectTokenType: x.subjectTokenType } : {}, resource: url, ...x.scope ? { scope: x.scope } : {}, serverClient: client(x.serverClientId, x.serverClientSecret), ...x.audience ? { audience: x.audience } : {}, ...x.tokenEndpoint ? { tokenEndpoint: x.tokenEndpoint } : {} }, o.f, now);
|
|
95
|
+
} catch (e) {
|
|
96
|
+
throw e instanceof SecretError ? e : new SecretError(`no token for ${key} from the identity provider: ${e.message}`);
|
|
97
|
+
}
|
|
98
|
+
store.tokens[key] = t;
|
|
99
|
+
saveTokens(store, file);
|
|
100
|
+
}
|
|
101
|
+
if (!t) throw new SecretError(`${key} isn't signed in on this machine`, `instruction-agents signin ${key.split("@")[0]}${key.includes("@") ? ` --account ${key.split("@")[1]}` : ""}${o.url ? ` --url ${o.url}` : ""}`);
|
|
102
|
+
return { [header]: `${scheme || "Bearer"} ${t.access_token}` };
|
|
103
|
+
}
|
|
104
|
+
throw new SecretError(`the entry for ${key} says nowhere to find its credential`, `instruction-agents accounts set ${key} --env VAR`);
|
|
105
|
+
}
|
|
106
|
+
function hostEnv(a, host, env = process.env) {
|
|
107
|
+
const h = a.hosts[host];
|
|
108
|
+
if (!h) return {};
|
|
109
|
+
return { [h.env]: secretOf(h.from, env) };
|
|
110
|
+
}
|
|
111
|
+
function take(args, flag) {
|
|
112
|
+
const i = args.indexOf(flag);
|
|
113
|
+
if (i < 0) return void 0;
|
|
114
|
+
const v = args[i + 1];
|
|
115
|
+
if (v === void 0) throw new OAuthError(`${flag} needs a value`, 2);
|
|
116
|
+
args.splice(i, 2);
|
|
117
|
+
return v;
|
|
118
|
+
}
|
|
119
|
+
function has(args, flag) {
|
|
120
|
+
const i = args.indexOf(flag);
|
|
121
|
+
if (i < 0) return false;
|
|
122
|
+
args.splice(i, 1);
|
|
123
|
+
return true;
|
|
124
|
+
}
|
|
125
|
+
var KEY = /^[A-Za-z0-9][A-Za-z0-9._-]*(@[A-Za-z0-9][A-Za-z0-9._-]*)?$/;
|
|
126
|
+
var ACCOUNTS_USAGE = `usage:
|
|
127
|
+
instruction-agents accounts what each server and host uses on this machine
|
|
128
|
+
instruction-agents accounts set <server[@account]> (--env VAR | --command CMD | --oauth | --xaa-idp URL --xaa-client-id ID
|
|
129
|
+
--xaa-subject-env V|--xaa-subject-command C --xaa-server-client-id ID [--xaa-client-secret-env V|--xaa-client-secret-command C]
|
|
130
|
+
[--xaa-server-client-secret-env V|--xaa-server-client-secret-command C] [--xaa-scope S] [--xaa-audience ISS])
|
|
131
|
+
[--header NAME] [--scheme WORD]
|
|
132
|
+
instruction-agents accounts host <claude-code|codex> --env VAR (--from-env V | --from-command C)
|
|
133
|
+
instruction-agents accounts remove <server[@account]> | instruction-agents accounts remove-host <name>`;
|
|
134
|
+
var src = (args, envFlag, cmdFlag) => {
|
|
135
|
+
const e = take(args, envFlag), c = take(args, cmdFlag);
|
|
136
|
+
if (e && c) throw new OAuthError(`${envFlag} or ${cmdFlag}, not both`, 2);
|
|
137
|
+
return e ? { env: e } : c ? { command: c } : void 0;
|
|
138
|
+
};
|
|
139
|
+
async function cmdAccounts(argv) {
|
|
140
|
+
const args = [...argv];
|
|
141
|
+
const json = has(args, "--json");
|
|
142
|
+
const file = take(args, "--file") ?? accountsPath();
|
|
143
|
+
const sub = args.shift() ?? "list";
|
|
144
|
+
const a = loadAccounts(file);
|
|
145
|
+
if (sub === "list") {
|
|
146
|
+
if (json) {
|
|
147
|
+
console.log(JSON.stringify({ file, servers: Object.fromEntries(Object.entries(a.servers).map(([k, e]) => [k, describeEntry(e)])), hosts: Object.fromEntries(Object.entries(a.hosts).map(([k, h2]) => [k, `${h2.env} from ${"env" in h2.from ? `the variable ${h2.from.env}` : "a command"}`])) }, null, 2));
|
|
148
|
+
return 0;
|
|
149
|
+
}
|
|
150
|
+
const s = Object.entries(a.servers), h = Object.entries(a.hosts);
|
|
151
|
+
if (!s.length && !h.length) {
|
|
152
|
+
console.log(`No accounts on this machine yet (${file}).
|
|
153
|
+
|
|
154
|
+
${ACCOUNTS_USAGE}`);
|
|
155
|
+
return 0;
|
|
156
|
+
}
|
|
157
|
+
for (const [k, e] of s) console.log(`${k.padEnd(28)} ${describeEntry(e)}`);
|
|
158
|
+
for (const [k, x] of h) console.log(`${`host ${k}`.padEnd(28)} ${x.env} from ${"env" in x.from ? `the variable ${x.from.env}` : `the command ${x.from.command.split(/\s+/)[0]}…`}`);
|
|
159
|
+
return 0;
|
|
160
|
+
}
|
|
161
|
+
if (sub === "set") {
|
|
162
|
+
const key = args.shift();
|
|
163
|
+
if (!key || !KEY.test(key)) {
|
|
164
|
+
console.error(`name the server (its id in the instruction, or id@account)
|
|
165
|
+
|
|
166
|
+
${ACCOUNTS_USAGE}`);
|
|
167
|
+
return 2;
|
|
168
|
+
}
|
|
169
|
+
const header = take(args, "--header"), scheme = take(args, "--scheme");
|
|
170
|
+
const env = take(args, "--env"), command = take(args, "--command"), oauth = has(args, "--oauth");
|
|
171
|
+
const idp = take(args, "--xaa-idp");
|
|
172
|
+
let entry;
|
|
173
|
+
if (idp) {
|
|
174
|
+
const clientId = take(args, "--xaa-client-id"), serverClientId = take(args, "--xaa-server-client-id");
|
|
175
|
+
const subjectToken = src(args, "--xaa-subject-env", "--xaa-subject-command");
|
|
176
|
+
if (!clientId || !serverClientId || !subjectToken) {
|
|
177
|
+
console.error(`--xaa-idp needs --xaa-client-id, --xaa-server-client-id and --xaa-subject-env or --xaa-subject-command
|
|
178
|
+
|
|
179
|
+
${ACCOUNTS_USAGE}`);
|
|
180
|
+
return 2;
|
|
181
|
+
}
|
|
182
|
+
const clientSecret = src(args, "--xaa-client-secret-env", "--xaa-client-secret-command"), serverClientSecret = src(args, "--xaa-server-client-secret-env", "--xaa-server-client-secret-command");
|
|
183
|
+
const scope = take(args, "--xaa-scope"), audience = take(args, "--xaa-audience");
|
|
184
|
+
entry = { xaa: { idp, clientId, subjectToken, serverClientId, ...clientSecret ? { clientSecret } : {}, ...serverClientSecret ? { serverClientSecret } : {}, ...scope ? { scope } : {}, ...audience ? { audience } : {} } };
|
|
185
|
+
} else entry = env ? { env } : command ? { command } : oauth ? { oauth: true } : {};
|
|
186
|
+
if ([env, command, oauth || void 0, idp].filter(Boolean).length !== 1) {
|
|
187
|
+
console.error(`one of --env, --command, --oauth or --xaa-idp
|
|
188
|
+
|
|
189
|
+
${ACCOUNTS_USAGE}`);
|
|
190
|
+
return 2;
|
|
191
|
+
}
|
|
192
|
+
if (args.length) {
|
|
193
|
+
console.error(`not understood: ${args.join(" ")}
|
|
194
|
+
|
|
195
|
+
${ACCOUNTS_USAGE}`);
|
|
196
|
+
return 2;
|
|
197
|
+
}
|
|
198
|
+
if (header) entry.header = header;
|
|
199
|
+
if (scheme !== void 0) entry.scheme = scheme;
|
|
200
|
+
a.servers[key] = entry;
|
|
201
|
+
saveAccounts(a, file);
|
|
202
|
+
console.log(`${key}: ${describeEntry(entry)} (${file})${oauth ? `
|
|
203
|
+
Now sign in: instruction-agents signin ${key.split("@")[0]}${key.includes("@") ? ` --account ${key.split("@")[1]}` : ""} --url <its address>` : ""}`);
|
|
204
|
+
return 0;
|
|
205
|
+
}
|
|
206
|
+
if (sub === "host") {
|
|
207
|
+
const name = args.shift(), env = take(args, "--env");
|
|
208
|
+
const from = src(args, "--from-env", "--from-command");
|
|
209
|
+
if (!name || !env || !from || args.length) {
|
|
210
|
+
console.error(ACCOUNTS_USAGE);
|
|
211
|
+
return 2;
|
|
212
|
+
}
|
|
213
|
+
a.hosts[name] = { env, from };
|
|
214
|
+
saveAccounts(a, file);
|
|
215
|
+
console.log(`host ${name}: ${env} from ${"env" in from ? `the variable ${from.env}` : "a command"} (${file}); \`instruction-agents fleet\` sets it for each agent it starts`);
|
|
216
|
+
return 0;
|
|
217
|
+
}
|
|
218
|
+
if (sub === "remove" || sub === "remove-host") {
|
|
219
|
+
const key = args.shift();
|
|
220
|
+
const table = sub === "remove" ? a.servers : a.hosts;
|
|
221
|
+
if (!key || !table[key]) {
|
|
222
|
+
console.error(`no ${sub === "remove" ? "server" : "host"} ${key ?? ""} in ${file}`);
|
|
223
|
+
return 4;
|
|
224
|
+
}
|
|
225
|
+
delete table[key];
|
|
226
|
+
saveAccounts(a, file);
|
|
227
|
+
if (sub === "remove") {
|
|
228
|
+
const t = loadTokens();
|
|
229
|
+
if (t.tokens[key]) {
|
|
230
|
+
delete t.tokens[key];
|
|
231
|
+
saveTokens(t);
|
|
232
|
+
}
|
|
233
|
+
}
|
|
234
|
+
console.log(`removed ${key}`);
|
|
235
|
+
return 0;
|
|
236
|
+
}
|
|
237
|
+
console.error(ACCOUNTS_USAGE);
|
|
238
|
+
return 2;
|
|
239
|
+
}
|
|
240
|
+
async function cmdCredential(argv) {
|
|
241
|
+
const args = [...argv];
|
|
242
|
+
const account = take(args, "--account"), url = take(args, "--url") ?? process.env.CLAUDE_CODE_MCP_SERVER_URL, show = has(args, "--show");
|
|
243
|
+
const file = take(args, "--accounts");
|
|
244
|
+
const id = args.shift() ?? process.env.CLAUDE_CODE_MCP_SERVER_NAME;
|
|
245
|
+
if (!id || args.length) {
|
|
246
|
+
console.error("usage: instruction-agents credential <server> [--account A] [--url U]");
|
|
247
|
+
return 2;
|
|
248
|
+
}
|
|
249
|
+
if (process.stdout.isTTY && !show) {
|
|
250
|
+
console.error("instruction-agents credential prints a secret for an agent's app to read; it doesn't print to a terminal (run `instruction-agents doctor` to check it works)");
|
|
251
|
+
return 2;
|
|
252
|
+
}
|
|
253
|
+
const a = loadAccounts(file ?? accountsPath());
|
|
254
|
+
const found = entryFor(a, id, account);
|
|
255
|
+
if (!found) {
|
|
256
|
+
console.error(`instruction.md: no account for ${account ? `${id}@${account}` : id} on this machine: instruction-agents accounts set ${account ? `${id}@${account}` : id} …`);
|
|
257
|
+
return 4;
|
|
258
|
+
}
|
|
259
|
+
try {
|
|
260
|
+
const h = await headersFor(found.key, found.entry, { ...url ? { url } : {}, ...file ? { tokensFile: join(dirname(file), "mcp-tokens.json") } : {} });
|
|
261
|
+
process.stdout.write(`${JSON.stringify(h)}
|
|
262
|
+
`);
|
|
263
|
+
return 0;
|
|
264
|
+
} catch (e) {
|
|
265
|
+
console.error(`instruction.md: ${e.message}${e instanceof SecretError && e.fix ? ` — ${e.fix}` : ""}`);
|
|
266
|
+
return 3;
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
async function cmdSignin(argv) {
|
|
270
|
+
const args = [...argv];
|
|
271
|
+
const account = take(args, "--account"), scope = take(args, "--scope"), clientId = take(args, "--client-id");
|
|
272
|
+
const clientSecretEnv = take(args, "--client-secret-env");
|
|
273
|
+
const device = has(args, "--device"), noBrowser = has(args, "--no-browser");
|
|
274
|
+
let url = take(args, "--url");
|
|
275
|
+
const id = args.shift();
|
|
276
|
+
if (!id || args.length || !KEY.test(account ? `${id}@${account}` : id)) {
|
|
277
|
+
console.error("usage: instruction-agents signin <server> --url U [--account A] [--device] [--no-browser] [--scope S] [--client-id ID [--client-secret-env V]]");
|
|
278
|
+
return 2;
|
|
279
|
+
}
|
|
280
|
+
const key = account ? `${id}@${account}` : id;
|
|
281
|
+
const store = loadTokens();
|
|
282
|
+
url ??= store.tokens[key]?.resource ?? appliedUrl(id);
|
|
283
|
+
if (!url) {
|
|
284
|
+
console.error(`name the server's address: instruction-agents signin ${id}${account ? ` --account ${account}` : ""} --url https://…`);
|
|
285
|
+
return 2;
|
|
286
|
+
}
|
|
287
|
+
try {
|
|
288
|
+
const t = await signIn({ url, ...scope ? { scope } : {}, ...clientId ? { clientId } : {}, ...clientSecretEnv ? { clientSecret: secretOf({ env: clientSecretEnv }) } : {}, device, noBrowser });
|
|
289
|
+
const s = loadTokens();
|
|
290
|
+
s.tokens[key] = t;
|
|
291
|
+
saveTokens(s);
|
|
292
|
+
const a = loadAccounts();
|
|
293
|
+
if (!a.servers[key]?.oauth) {
|
|
294
|
+
a.servers[key] = { ...a.servers[key]?.header ? { header: a.servers[key].header } : {}, oauth: true };
|
|
295
|
+
saveAccounts(a);
|
|
296
|
+
}
|
|
297
|
+
console.error(`Signed in to ${new URL(url).host} as ${key} on this machine.`);
|
|
298
|
+
return 0;
|
|
299
|
+
} catch (e) {
|
|
300
|
+
console.error(e instanceof Error ? e.message : String(e));
|
|
301
|
+
return e instanceof OAuthError ? e.code : 1;
|
|
302
|
+
}
|
|
303
|
+
}
|
|
304
|
+
function appliedUrl(id) {
|
|
305
|
+
try {
|
|
306
|
+
const a = JSON.parse(readFileSync(join(process.cwd(), ".instruction", "applied.json"), "utf8"));
|
|
307
|
+
return a.servers?.find((s) => s.id === id)?.url;
|
|
308
|
+
} catch {
|
|
309
|
+
return void 0;
|
|
310
|
+
}
|
|
311
|
+
}
|
|
312
|
+
export {
|
|
313
|
+
ACCOUNTS_USAGE,
|
|
314
|
+
SecretError,
|
|
315
|
+
accountsPath,
|
|
316
|
+
cmdAccounts,
|
|
317
|
+
cmdCredential,
|
|
318
|
+
cmdSignin,
|
|
319
|
+
describeEntry,
|
|
320
|
+
entryFor,
|
|
321
|
+
headersFor,
|
|
322
|
+
hostEnv,
|
|
323
|
+
keysFor,
|
|
324
|
+
loadAccounts,
|
|
325
|
+
saveAccounts,
|
|
326
|
+
secretOf
|
|
327
|
+
};
|