owenloop 0.5.19 → 0.5.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +14 -0
- package/dist/src/cli.js +154 -2
- package/dist/src/hub.d.ts +16 -0
- package/dist/src/hub.js +43 -0
- package/dist/src/store/instruction-source.js +191 -43
- package/docs/bundles.md +1 -1
- package/docs/cli.md +80 -0
- package/docs/design.md +15 -4
- package/docs/embedding.md +7 -3
- package/package.json +1 -1
- package/plugins/claude-code/plugin/.claude-plugin/plugin.json +1 -1
- package/plugins/claude-code/plugin/.mcp.json +1 -1
- package/plugins/codex/plugins/owenloop/.codex-plugin/plugin.json +1 -1
- package/plugins/codex/plugins/owenloop/.mcp.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -4,6 +4,20 @@ All notable changes to this project are documented here. The format is based on
|
|
|
4
4
|
[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
|
|
5
5
|
adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
|
6
6
|
|
|
7
|
+
## [0.5.21](https://github.com/typicalday/owenloop/compare/v0.5.20...v0.5.21) (2026-08-22)
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
### Bug Fixes
|
|
11
|
+
|
|
12
|
+
* **work:** resolve bundle-locked calls targets on workers ([#287](https://github.com/typicalday/owenloop/issues/287)) ([a2a6b47](https://github.com/typicalday/owenloop/commit/a2a6b47699ddc8b02f8f645ecc4a0ddd5269cf11))
|
|
13
|
+
|
|
14
|
+
## [0.5.20](https://github.com/typicalday/owenloop/compare/v0.5.19...v0.5.20) (2026-08-22)
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
### Features
|
|
18
|
+
|
|
19
|
+
* **cli:** manage the hub interface catalog ([#285](https://github.com/typicalday/owenloop/issues/285)) ([ca83565](https://github.com/typicalday/owenloop/commit/ca83565aa0d1a1f41c96c954b2f4add4b5b3ec65))
|
|
20
|
+
|
|
7
21
|
## [0.5.19](https://github.com/typicalday/owenloop/compare/v0.5.18...v0.5.19) (2026-08-22)
|
|
8
22
|
|
|
9
23
|
|
package/dist/src/cli.js
CHANGED
|
@@ -63,7 +63,7 @@ import { BundleError, digestBundle, inspectBundle, packBundle, unpackBundle } fr
|
|
|
63
63
|
import { acquireInstallLock, ADD_JOURNAL_FILENAME, archivePathViolation, commitInstall, finalizeInstallCommit, githubShaUrl, githubTarballUrl, installFolder, parkOldNameDir, parseRepoSpec, readLockfile, recoverInterruptedInstall, releaseInstallLock, removeAddJournal, rmRecursiveForce, rollbackInstallCommit, RollbackFailedError, stageFiles, STAGING_DIRNAME, writeAddJournal, writeLockfile, } from "./add.js";
|
|
64
64
|
import { BundleIngestorUnavailableError, collectWorkflowStoreGarbage, compareStoreText, globalStoreRoot, installWorkflowBundle, inspectCasDefs, loadCasDefs, PreCommitVerifierUnavailableError, parseWorkflowCoordinate, projectStoreRoot, createBundleIngestor, createPreCommitVerifier, recoverWorkflowStore, storeIndexPath, workflowStoreReplacementRecovery, workflowStoreStatePaths, } from "./store/index.js";
|
|
65
65
|
import { recoverInterruptedWorkflowStoreGc } from "./store/gc-recovery.js";
|
|
66
|
-
import { asAgentIdentities, asCreateWorkflowOk, capabilityPublishReportText, asCapabilityRerouteAdded, asCapabilityRerouteRemoved, asCapabilityReroutes, asCapabilityRouteAdded, asCapabilityRouteRemoved, asCapabilityRoutes, asCrewCreated, asCrewDeleted, asCrewMemberAdded, asCrewMemberRemoved, asCrews, asRoutingAlerts, asRunRouting, asWhoami, computeServerDiff, credentialBackend, createWorkflowError, credentialFilePath, credentialSlot, DEFAULT_HUB, externalCredentialCommand, hashDefForHub, hubBindingPath, keychainServiceFor, listStoredHubOrigins, normalizeOrigin, parseWorkflowList, pkcePair, randomState, readCredentialFile, readHubBinding, readStoredCredential, resolveEndpoint, resolveKeychain, writeCredentialFile, writeHubBinding, } from "./hub.js";
|
|
66
|
+
import { asAgentIdentities, asCreateWorkflowOk, capabilityPublishReportText, asCapabilityRerouteAdded, asCapabilityRerouteRemoved, asCapabilityReroutes, asCapabilityRouteAdded, asCapabilityRouteRemoved, asCapabilityRoutes, asInterfaceCatalogList, asInterfaceCatalogVersion, asCrewCreated, asCrewDeleted, asCrewMemberAdded, asCrewMemberRemoved, asCrews, asRoutingAlerts, asRunRouting, asWhoami, computeServerDiff, credentialBackend, createWorkflowError, credentialFilePath, credentialSlot, DEFAULT_HUB, externalCredentialCommand, hashDefForHub, hubBindingPath, keychainServiceFor, listStoredHubOrigins, normalizeOrigin, parseWorkflowList, pkcePair, randomState, readCredentialFile, readHubBinding, readStoredCredential, resolveEndpoint, resolveKeychain, writeCredentialFile, writeHubBinding, } from "./hub.js";
|
|
67
67
|
import { fetchCapabilityMappings, recordCapabilityMappings } from "./capability-mapping-client.js";
|
|
68
68
|
import { MODIFIER_SEPARATOR } from "./capabilities.js";
|
|
69
69
|
import { loadSettings, settingsPath as executionSettingsPath } from "../packages/work/src/settings/settings.js";
|
|
@@ -1245,6 +1245,9 @@ ${' '.repeat(41)}the instance has reached a terminal status.
|
|
|
1245
1245
|
capability bind <capability> <crew> [--hub <url>] add a crew to a workflow capability on the hub org — a capability may bind many crews (admin; human credential)
|
|
1246
1246
|
capability unbind <capability> <crew> [--hub <url>] remove one (capability, crew) route
|
|
1247
1247
|
capability list [--hub <url>] list the hub org's capability routes
|
|
1248
|
+
interface register <name> <version> --signature <file> [--hub <url>]
|
|
1249
|
+
interface get <name> <version> [--hub <url>]
|
|
1250
|
+
interface list [--hub <url>]
|
|
1248
1251
|
routing alerts [--workflow <wf>] [--limit <n>] [--hub <url>]
|
|
1249
1252
|
${' '.repeat(41)}list the hub org's routing alerts — newest first org-wide; --workflow scopes to
|
|
1250
1253
|
${' '.repeat(41)}one run and flips to oldest first. A \`binding-gap\` alert means the hub HELD an
|
|
@@ -1361,6 +1364,7 @@ export const COMMAND_OPTIONS = new Map([
|
|
|
1361
1364
|
['instance', cmdOpts('hub')],
|
|
1362
1365
|
['agent', cmdOpts('crews', 'hub', 'scopes', 'shift')],
|
|
1363
1366
|
['capability', cmdOpts('hub')],
|
|
1367
|
+
['interface', cmdOpts('hub', 'signature')],
|
|
1364
1368
|
// Per-TOP-LEVEL-command allowlist, not per-subcommand: `--position` on
|
|
1365
1369
|
// `routing alerts` is meaningless but accepted and ignored, exactly as
|
|
1366
1370
|
// `--kind` is on `crew list`. Policing flags per subcommand is deliberately
|
|
@@ -6105,6 +6109,152 @@ async function dispatchAgent(io, args) {
|
|
|
6105
6109
|
});
|
|
6106
6110
|
return 0;
|
|
6107
6111
|
}
|
|
6112
|
+
/**
|
|
6113
|
+
* `owenloop interface register|get|list` — administer the hub's immutable
|
|
6114
|
+
* interface catalog without inspecting the signature's schema semantics.
|
|
6115
|
+
*
|
|
6116
|
+
* | subcommand | endpoint | auth principal |
|
|
6117
|
+
* |---|---|---|
|
|
6118
|
+
* | `interface register <name> <version> --signature <file>` | `POST /api/register_interface` | human (admin role on the hub) |
|
|
6119
|
+
* | `interface get <name> <version>` | `GET /api/interfaces/:name/:version` | human (`get_status`) |
|
|
6120
|
+
* | `interface list` | `GET /api/interfaces` | human (`get_status`) |
|
|
6121
|
+
*
|
|
6122
|
+
* This namespace stores no credential locally, so it deliberately permits an
|
|
6123
|
+
* `OWENLOOP_CREDENTIAL_COMMAND` backend just like `capability`. It accepts
|
|
6124
|
+
* opaque coordinates and an opaque, JSON-parsed signature without client-side
|
|
6125
|
+
* semantic validation; the hub owns all catalog validation. stdout is always
|
|
6126
|
+
* one whitelisted JSON document. Exit codes: 0 success; 1 runtime, hub, or
|
|
6127
|
+
* malformed-response error; 2 unresolvable hub; 3 absent or irrecoverable
|
|
6128
|
+
* human credential (with a runnable login remedy).
|
|
6129
|
+
*/
|
|
6130
|
+
async function dispatchInterface(io, args) {
|
|
6131
|
+
const USAGE_FORMS = 'usage: owenloop interface register <name> <version> --signature <file> [--hub <url>] | ' +
|
|
6132
|
+
'owenloop interface get <name> <version> [--hub <url>] | owenloop interface list [--hub <url>]';
|
|
6133
|
+
const sub = args.positionals[1];
|
|
6134
|
+
if (sub !== 'register' && sub !== 'get' && sub !== 'list') {
|
|
6135
|
+
throw new CliError(`unknown interface subcommand '${sub ?? ''}' — ${USAGE_FORMS}`);
|
|
6136
|
+
}
|
|
6137
|
+
const signatureFlags = all(args, 'signature');
|
|
6138
|
+
let name = '';
|
|
6139
|
+
let version = '';
|
|
6140
|
+
if (sub === 'list') {
|
|
6141
|
+
if (args.positionals[2] !== undefined) {
|
|
6142
|
+
throw new CliError(`interface list takes no positional arguments — ${USAGE_FORMS}`);
|
|
6143
|
+
}
|
|
6144
|
+
if (signatureFlags.length > 0) {
|
|
6145
|
+
throw new CliError(`--signature is only valid for interface register — ${USAGE_FORMS}`);
|
|
6146
|
+
}
|
|
6147
|
+
}
|
|
6148
|
+
else {
|
|
6149
|
+
const rawName = args.positionals[2];
|
|
6150
|
+
const rawVersion = args.positionals[3];
|
|
6151
|
+
if (rawName === undefined || rawName === '') {
|
|
6152
|
+
throw new CliError(`missing required argument: <name> (${USAGE_FORMS})`);
|
|
6153
|
+
}
|
|
6154
|
+
if (rawVersion === undefined || rawVersion === '') {
|
|
6155
|
+
throw new CliError(`missing required argument: <version> (${USAGE_FORMS})`);
|
|
6156
|
+
}
|
|
6157
|
+
if (args.positionals[4] !== undefined) {
|
|
6158
|
+
throw new CliError(`too many positional arguments — ${USAGE_FORMS}`);
|
|
6159
|
+
}
|
|
6160
|
+
name = rawName;
|
|
6161
|
+
version = rawVersion;
|
|
6162
|
+
if (sub === 'get' && signatureFlags.length > 0) {
|
|
6163
|
+
throw new CliError(`--signature is only valid for interface register — ${USAGE_FORMS}`);
|
|
6164
|
+
}
|
|
6165
|
+
}
|
|
6166
|
+
let signature;
|
|
6167
|
+
if (sub === 'register') {
|
|
6168
|
+
if (signatureFlags.length !== 1 || args.missingOptionValues.has('signature') || signatureFlags[0] === '') {
|
|
6169
|
+
throw new CliError(`interface register requires exactly one non-empty --signature <file> — ${USAGE_FORMS}`);
|
|
6170
|
+
}
|
|
6171
|
+
const signaturePath = resolve(io.cwd, signatureFlags[0]);
|
|
6172
|
+
let source;
|
|
6173
|
+
try {
|
|
6174
|
+
source = readFileSync(signaturePath, 'utf8');
|
|
6175
|
+
}
|
|
6176
|
+
catch (e) {
|
|
6177
|
+
throw new CliError(`cannot read interface signature file ${signaturePath}: ${e.message}`);
|
|
6178
|
+
}
|
|
6179
|
+
try {
|
|
6180
|
+
signature = JSON.parse(source);
|
|
6181
|
+
}
|
|
6182
|
+
catch {
|
|
6183
|
+
throw new CliError('interface signature file is not valid JSON');
|
|
6184
|
+
}
|
|
6185
|
+
}
|
|
6186
|
+
// All input validation and the only local file read happened above: hub,
|
|
6187
|
+
// credential, and network work cannot obscure a usage failure.
|
|
6188
|
+
const origin = resolveAgentHub(io, args, 'manage interfaces on');
|
|
6189
|
+
const slot = { principal: 'human' };
|
|
6190
|
+
const credential = readCredential(io, origin, slot);
|
|
6191
|
+
if (credential === null) {
|
|
6192
|
+
throw new CliError(`no human credential for ${origin} — run: owenloop login --hub ${origin}`, { exitCode: 3 });
|
|
6193
|
+
}
|
|
6194
|
+
try {
|
|
6195
|
+
let res;
|
|
6196
|
+
let endpoint;
|
|
6197
|
+
if (sub === 'register') {
|
|
6198
|
+
({ res } = await authedPost(io, origin, slot, credential, '/api/register_interface', { name, version, signature }));
|
|
6199
|
+
endpoint = 'register_interface';
|
|
6200
|
+
}
|
|
6201
|
+
else if (sub === 'get') {
|
|
6202
|
+
({ res } = await authedGet(io, origin, slot, credential, `/api/interfaces/${encodeURIComponent(name)}/${encodeURIComponent(version)}`));
|
|
6203
|
+
endpoint = 'interfaces';
|
|
6204
|
+
}
|
|
6205
|
+
else {
|
|
6206
|
+
({ res } = await authedGet(io, origin, slot, credential, '/api/interfaces'));
|
|
6207
|
+
endpoint = 'interfaces';
|
|
6208
|
+
}
|
|
6209
|
+
if (res.status === 401) {
|
|
6210
|
+
throw new CliError('credential rejected by the hub — run `owenloop login`');
|
|
6211
|
+
}
|
|
6212
|
+
if (!res.ok) {
|
|
6213
|
+
throw new CliError((await hubRequestMessage(res)) ?? `hub ${origin} rejected the request (HTTP ${res.status})`);
|
|
6214
|
+
}
|
|
6215
|
+
let body;
|
|
6216
|
+
try {
|
|
6217
|
+
body = (await res.json());
|
|
6218
|
+
}
|
|
6219
|
+
catch {
|
|
6220
|
+
throw new CliError(`${endpoint}: malformed success response — body is not valid JSON`);
|
|
6221
|
+
}
|
|
6222
|
+
if (sub === 'list') {
|
|
6223
|
+
let interfaces;
|
|
6224
|
+
try {
|
|
6225
|
+
interfaces = asInterfaceCatalogList(body);
|
|
6226
|
+
}
|
|
6227
|
+
catch (e) {
|
|
6228
|
+
throw new CliError(e.message);
|
|
6229
|
+
}
|
|
6230
|
+
print(io, { ok: true, hub: origin, interfaces });
|
|
6231
|
+
return 0;
|
|
6232
|
+
}
|
|
6233
|
+
let result;
|
|
6234
|
+
try {
|
|
6235
|
+
result = asInterfaceCatalogVersion(body, endpoint);
|
|
6236
|
+
}
|
|
6237
|
+
catch (e) {
|
|
6238
|
+
throw new CliError(e.message);
|
|
6239
|
+
}
|
|
6240
|
+
print(io, {
|
|
6241
|
+
ok: true,
|
|
6242
|
+
hub: origin,
|
|
6243
|
+
name: result.name,
|
|
6244
|
+
version: result.version,
|
|
6245
|
+
signature: result.signature,
|
|
6246
|
+
createdBy: result.createdBy,
|
|
6247
|
+
createdAt: result.createdAt,
|
|
6248
|
+
});
|
|
6249
|
+
return 0;
|
|
6250
|
+
}
|
|
6251
|
+
catch (e) {
|
|
6252
|
+
if (e instanceof CliError && /run `owenloop login`/.test(e.message)) {
|
|
6253
|
+
throw new CliError(`${e.message} — run: owenloop login --hub ${origin}`, { exitCode: 3 });
|
|
6254
|
+
}
|
|
6255
|
+
throw e;
|
|
6256
|
+
}
|
|
6257
|
+
}
|
|
6108
6258
|
/**
|
|
6109
6259
|
* `owenloop capability bind|unbind|list` — manage the hub org's **capability routes**, the
|
|
6110
6260
|
* admin-owned table mapping a workflow-def `capabilities:` entry to a crew.
|
|
@@ -8326,7 +8476,7 @@ async function runDoctor(io, origin) {
|
|
|
8326
8476
|
* the async path, so every existing command and test keeps working exactly as
|
|
8327
8477
|
* before.
|
|
8328
8478
|
*/
|
|
8329
|
-
export const ASYNC_COMMANDS = new Set(['add', 'login', 'logout', 'connect', 'publish', 'trust', 'push', 'install', 'start', 'pending-gates', 'cancel', 'provide', 'reject', 'retry', 'instance', 'agent', 'capability', 'routing', 'crew', 'roster', 'setup', 'doctor', 'enrollments', 'mcp', 'shift']);
|
|
8479
|
+
export const ASYNC_COMMANDS = new Set(['add', 'login', 'logout', 'connect', 'publish', 'trust', 'push', 'install', 'start', 'pending-gates', 'cancel', 'provide', 'reject', 'retry', 'instance', 'agent', 'capability', 'interface', 'routing', 'crew', 'roster', 'setup', 'doctor', 'enrollments', 'mcp', 'shift']);
|
|
8330
8480
|
export async function mainAsync(argv, io = defaultIO()) {
|
|
8331
8481
|
// Delegate execution-side and shift argv tails before root parsing. Their
|
|
8332
8482
|
// roles own their option grammars, including repeated/value forms that the
|
|
@@ -8400,6 +8550,8 @@ export async function mainAsync(argv, io = defaultIO()) {
|
|
|
8400
8550
|
return await dispatchAgent(io, args);
|
|
8401
8551
|
case 'capability':
|
|
8402
8552
|
return await dispatchCapability(io, args);
|
|
8553
|
+
case 'interface':
|
|
8554
|
+
return await dispatchInterface(io, args);
|
|
8403
8555
|
case 'routing':
|
|
8404
8556
|
return await dispatchRouting(io, args);
|
|
8405
8557
|
case 'crew':
|
package/dist/src/hub.d.ts
CHANGED
|
@@ -862,6 +862,22 @@ export declare function asCapabilityRouteRemoved(body: unknown): {
|
|
|
862
862
|
* whose `crewName` is `null` is a dangling route and is kept, not dropped.
|
|
863
863
|
*/
|
|
864
864
|
export declare function asCapabilityRoutes(body: unknown): CapabilityRouteWire[];
|
|
865
|
+
/** One signature-free row returned by `GET /api/interfaces`. */
|
|
866
|
+
export interface InterfaceCatalogRowWire {
|
|
867
|
+
name: string;
|
|
868
|
+
version: string;
|
|
869
|
+
createdBy: string;
|
|
870
|
+
createdAt: number;
|
|
871
|
+
}
|
|
872
|
+
/** The exact-coordinate form returned by register and exact get. */
|
|
873
|
+
export interface InterfaceCatalogVersionWire extends InterfaceCatalogRowWire {
|
|
874
|
+
/** Opaque hub-owned signature. The CLI deliberately does not validate its semantics. */
|
|
875
|
+
signature: unknown;
|
|
876
|
+
}
|
|
877
|
+
/** Narrow a register or exact-get response while retaining its opaque signature. */
|
|
878
|
+
export declare function asInterfaceCatalogVersion(body: unknown, endpoint: 'register_interface' | 'interfaces'): InterfaceCatalogVersionWire;
|
|
879
|
+
/** Narrow `GET /api/interfaces`, preserving the hub's opaque row order. */
|
|
880
|
+
export declare function asInterfaceCatalogList(body: unknown): InterfaceCatalogRowWire[];
|
|
865
881
|
/**
|
|
866
882
|
* One **routing alert** as the hub reports it — an org-scoped record that the
|
|
867
883
|
* hub made a routing decision an operator needs to know about.
|
package/dist/src/hub.js
CHANGED
|
@@ -1286,6 +1286,49 @@ export function asCapabilityRoutes(body) {
|
|
|
1286
1286
|
const list = body.bindings;
|
|
1287
1287
|
return list.map((entry, i) => asCapabilityRouteRow(entry, 'capability_routes: malformed response', `bindings[${i}]`));
|
|
1288
1288
|
}
|
|
1289
|
+
/**
|
|
1290
|
+
* Narrow one interface-catalog row without interpreting the signature or any
|
|
1291
|
+
* schemas it may contain. The hub is the only semantic validator; this guard
|
|
1292
|
+
* only protects CLI output from malformed transport data.
|
|
1293
|
+
*/
|
|
1294
|
+
function asInterfaceCatalogRow(entry, prefix, where) {
|
|
1295
|
+
if (typeof entry !== 'object' || entry === null) {
|
|
1296
|
+
throw new Error(`${prefix} — ${where} is not an object`);
|
|
1297
|
+
}
|
|
1298
|
+
const value = entry;
|
|
1299
|
+
for (const field of ['name', 'version', 'createdBy']) {
|
|
1300
|
+
if (typeof value[field] !== 'string' || value[field] === '') {
|
|
1301
|
+
throw new Error(`${prefix} — ${where} missing non-empty string ${field}`);
|
|
1302
|
+
}
|
|
1303
|
+
}
|
|
1304
|
+
if (typeof value.createdAt !== 'number') {
|
|
1305
|
+
throw new Error(`${prefix} — ${where} missing number createdAt`);
|
|
1306
|
+
}
|
|
1307
|
+
return {
|
|
1308
|
+
name: value.name,
|
|
1309
|
+
version: value.version,
|
|
1310
|
+
createdBy: value.createdBy,
|
|
1311
|
+
createdAt: value.createdAt,
|
|
1312
|
+
};
|
|
1313
|
+
}
|
|
1314
|
+
/** Narrow a register or exact-get response while retaining its opaque signature. */
|
|
1315
|
+
export function asInterfaceCatalogVersion(body, endpoint) {
|
|
1316
|
+
const prefix = `${endpoint}: malformed response`;
|
|
1317
|
+
const row = asInterfaceCatalogRow(body, prefix, 'response');
|
|
1318
|
+
const value = body;
|
|
1319
|
+
if (!Object.prototype.hasOwnProperty.call(value, 'signature')) {
|
|
1320
|
+
throw new Error(`${prefix} — response missing signature`);
|
|
1321
|
+
}
|
|
1322
|
+
return { ...row, signature: value.signature };
|
|
1323
|
+
}
|
|
1324
|
+
/** Narrow `GET /api/interfaces`, preserving the hub's opaque row order. */
|
|
1325
|
+
export function asInterfaceCatalogList(body) {
|
|
1326
|
+
const prefix = 'interfaces: malformed response';
|
|
1327
|
+
if (typeof body !== 'object' || body === null || !Array.isArray(body.interfaces)) {
|
|
1328
|
+
throw new Error(`${prefix} — missing interfaces array`);
|
|
1329
|
+
}
|
|
1330
|
+
return body.interfaces.map((entry, index) => asInterfaceCatalogRow(entry, prefix, `interfaces[${index}]`));
|
|
1331
|
+
}
|
|
1289
1332
|
/**
|
|
1290
1333
|
* Validate the eight `RoutingAlertWire` fields on one row. `prefix` is the
|
|
1291
1334
|
* endpoint-qualified lead-in the caller wants (e.g.
|
|
@@ -7,13 +7,13 @@
|
|
|
7
7
|
* requested order digest. `lookup` then reads only the verified definition held
|
|
8
8
|
* in the in-memory cache populated by that prime.
|
|
9
9
|
*/
|
|
10
|
-
import {
|
|
10
|
+
import { join } from 'node:path';
|
|
11
11
|
import { readFileSync } from 'node:fs';
|
|
12
|
-
import { parseManifestBytes } from "../bundle/manifest.js";
|
|
12
|
+
import { isVersionedReference, parseManifestBytes } from "../bundle/manifest.js";
|
|
13
13
|
import { defInstructionDigest } from "../order-resolver.js";
|
|
14
|
-
import { finalizeDefs, loadDefFile } from "../defs.js";
|
|
14
|
+
import { digestScopedCallsTargetKey, finalizeDefs, loadDefFile } from "../defs.js";
|
|
15
15
|
import { readWorkflowStoreIndex } from "./index-file.js";
|
|
16
|
-
import { StoreIntegrityError, compareStoreText, defDigest, objectDirForDigest, } from "./types.js";
|
|
16
|
+
import { StoreIntegrityError, compareStoreText, defDigest, objectDirForDigest, parseWorkflowCoordinate, } from "./types.js";
|
|
17
17
|
import { coordinateDigestRead, projectStoreRoot, probeObjectDir, probeStoreRoot, storeIndexPath, } from "./resolve.js";
|
|
18
18
|
export class StoreInstructionSourceError extends Error {
|
|
19
19
|
name = 'StoreInstructionSourceError';
|
|
@@ -60,45 +60,191 @@ function asDefDigest(raw) {
|
|
|
60
60
|
return undefined;
|
|
61
61
|
}
|
|
62
62
|
}
|
|
63
|
+
function errorText(error) {
|
|
64
|
+
return error instanceof Error ? error.message : String(error);
|
|
65
|
+
}
|
|
66
|
+
/**
|
|
67
|
+
* Read every workflow from one exact, already-addressed object. This is shared
|
|
68
|
+
* by a requested parent and its lock-pinned dependencies so child bytes get
|
|
69
|
+
* precisely the same installed-object verification before they are parsed.
|
|
70
|
+
*/
|
|
71
|
+
async function loadVerifiedObject(root, bundleDigest, level, verifier) {
|
|
72
|
+
return coordinateDigestRead(root, bundleDigest, async () => {
|
|
73
|
+
const objectPath = await verifiedCandidateObject(root, bundleDigest, level, verifier);
|
|
74
|
+
try {
|
|
75
|
+
const manifest = parseManifestBytes(readFileSync(join(objectPath, 'bundle.yaml')));
|
|
76
|
+
const defs = new Map();
|
|
77
|
+
for (const [workflowName, workflowPath] of Object.entries(manifest.workflows)) {
|
|
78
|
+
const def = loadDefFile(join(objectPath, workflowPath));
|
|
79
|
+
if (def.name !== workflowName) {
|
|
80
|
+
throw new StoreIntegrityError('object-corrupt', bundleDigest, `workflow '${workflowPath}' has definition name '${def.name}', expected '${workflowName}'`);
|
|
81
|
+
}
|
|
82
|
+
// CAS provenance is part of calls: resolution, not the instruction
|
|
83
|
+
// projection. defInstructionDigest deliberately excludes it.
|
|
84
|
+
def.bundlePackage = manifest.package.name;
|
|
85
|
+
def.bundleDigest = bundleDigest;
|
|
86
|
+
def.bundleLock = { ...manifest.lock };
|
|
87
|
+
defs.set(def.name, def);
|
|
88
|
+
}
|
|
89
|
+
return { bundleDigest, objectPath, root, level, manifest, defs };
|
|
90
|
+
}
|
|
91
|
+
catch (error) {
|
|
92
|
+
if (error instanceof StoreIntegrityError)
|
|
93
|
+
throw error;
|
|
94
|
+
throw new StoreIntegrityError('object-corrupt', bundleDigest, errorText(error));
|
|
95
|
+
}
|
|
96
|
+
});
|
|
97
|
+
}
|
|
63
98
|
export function createStoreInstructionSource(args) {
|
|
64
99
|
const projectRoot = args.projectRoot === undefined ? undefined : projectStoreRoot(args.projectRoot);
|
|
65
100
|
const globalRoot = projectStoreRoot(args.globalRoot);
|
|
66
101
|
const cache = new Map();
|
|
67
102
|
const inFlight = new Map();
|
|
68
|
-
const
|
|
69
|
-
const
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
103
|
+
const configuredRoots = () => {
|
|
104
|
+
const roots = [];
|
|
105
|
+
if (projectRoot !== undefined)
|
|
106
|
+
roots.push({ root: projectRoot, level: 'project' });
|
|
107
|
+
roots.push({ root: globalRoot, level: 'global' });
|
|
108
|
+
return roots.filter((candidate, index) => roots.findIndex((other) => other.root === candidate.root) === index);
|
|
109
|
+
};
|
|
110
|
+
/**
|
|
111
|
+
* Build the private, verified closure required to validate exact locked
|
|
112
|
+
* calls. It intentionally walks only digests named by the parent chain, not
|
|
113
|
+
* the whole store: unrelated indexed corruption must not poison this order.
|
|
114
|
+
*/
|
|
115
|
+
const loadCandidate = async (requestedDigest, bundleDigest, root, level) => {
|
|
116
|
+
const parent = await loadVerifiedObject(root, bundleDigest, level, args.verifier);
|
|
117
|
+
const validation = new Map(parent.defs);
|
|
118
|
+
const support = new Map();
|
|
119
|
+
const loadedByRootAndDigest = new Map();
|
|
120
|
+
const registeredDependencies = new Set();
|
|
121
|
+
const walked = new Set();
|
|
122
|
+
const keyFor = (object) => `${object.root}:${object.bundleDigest}`;
|
|
123
|
+
const remember = (object) => {
|
|
124
|
+
support.set(keyFor(object), object);
|
|
125
|
+
};
|
|
126
|
+
const registerDependencyDefinitions = (object) => {
|
|
127
|
+
const key = keyFor(object);
|
|
128
|
+
if (registeredDependencies.has(key))
|
|
129
|
+
return;
|
|
130
|
+
registeredDependencies.add(key);
|
|
131
|
+
for (const [workflowName, def] of object.defs) {
|
|
132
|
+
validation.set(digestScopedCallsTargetKey(object.bundleDigest, workflowName), def);
|
|
76
133
|
}
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
134
|
+
};
|
|
135
|
+
remember(parent);
|
|
136
|
+
loadedByRootAndDigest.set(keyFor(parent), parent);
|
|
137
|
+
const dependencyRoots = (from) => {
|
|
138
|
+
const roots = [{ root: from.root, level: from.level }, ...configuredRoots()];
|
|
139
|
+
return roots.filter((candidate, index) => roots.findIndex((other) => other.root === candidate.root) === index);
|
|
140
|
+
};
|
|
141
|
+
const loadAt = async (childDigest, candidate) => {
|
|
142
|
+
const key = `${candidate.root}:${childDigest}`;
|
|
143
|
+
const existing = loadedByRootAndDigest.get(key);
|
|
144
|
+
if (existing !== undefined)
|
|
145
|
+
return existing;
|
|
146
|
+
const loaded = await loadVerifiedObject(candidate.root, childDigest, candidate.level, args.verifier);
|
|
147
|
+
loadedByRootAndDigest.set(key, loaded);
|
|
148
|
+
remember(loaded);
|
|
149
|
+
return loaded;
|
|
150
|
+
};
|
|
151
|
+
const selectLockedTarget = (target, childDigest, child) => {
|
|
152
|
+
let coordinate;
|
|
153
|
+
try {
|
|
154
|
+
coordinate = parseWorkflowCoordinate(target);
|
|
155
|
+
}
|
|
156
|
+
catch (error) {
|
|
157
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' has an invalid coordinate: ${errorText(error)}`);
|
|
158
|
+
}
|
|
159
|
+
if (coordinate.name !== child.manifest.package.name
|
|
160
|
+
|| coordinate.version !== child.manifest.package.version) {
|
|
161
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' does not match child manifest package '${child.manifest.package.name}@${child.manifest.package.version}'`);
|
|
162
|
+
}
|
|
163
|
+
const workflowName = child.manifest.default
|
|
164
|
+
?? (child.defs.size === 1 ? child.defs.keys().next().value : undefined);
|
|
165
|
+
if (workflowName === undefined) {
|
|
166
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} exports multiple workflows and has no default`);
|
|
167
|
+
}
|
|
168
|
+
const selected = child.defs.get(workflowName);
|
|
169
|
+
if (selected === undefined) {
|
|
170
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' selects missing child workflow '${workflowName}'`);
|
|
171
|
+
}
|
|
172
|
+
return selected;
|
|
173
|
+
};
|
|
174
|
+
const walkObject = async (object) => {
|
|
175
|
+
const objectKey = keyFor(object);
|
|
176
|
+
if (walked.has(objectKey))
|
|
177
|
+
return;
|
|
178
|
+
walked.add(objectKey);
|
|
179
|
+
for (const def of object.defs.values()) {
|
|
180
|
+
for (const step of def.steps) {
|
|
181
|
+
if (step.calls === undefined || !isVersionedReference(step.calls))
|
|
182
|
+
continue;
|
|
183
|
+
const target = step.calls;
|
|
184
|
+
if (!Object.prototype.hasOwnProperty.call(object.manifest.lock, target)) {
|
|
185
|
+
throw new StoreIntegrityError('object-corrupt', object.bundleDigest, `locked calls target '${target}' has no entry in parent bundle ${object.bundleDigest} manifest lock`);
|
|
186
|
+
}
|
|
187
|
+
const childDigest = defDigest(object.manifest.lock[target]);
|
|
188
|
+
let child;
|
|
189
|
+
for (const candidate of dependencyRoots(object)) {
|
|
190
|
+
try {
|
|
191
|
+
child = await loadAt(childDigest, candidate);
|
|
192
|
+
break;
|
|
193
|
+
}
|
|
194
|
+
catch (error) {
|
|
195
|
+
if (error instanceof StoreIntegrityError && error.code === 'object-missing')
|
|
196
|
+
continue;
|
|
197
|
+
const verified = error instanceof StoreIntegrityError
|
|
198
|
+
&& error.message.includes('object failed verification');
|
|
199
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} at ${candidate.level}-level root '${candidate.root}' ` +
|
|
200
|
+
`${verified ? 'failed installed-object verification' : 'could not load verified child'}: ${errorText(error)}`);
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
if (child === undefined) {
|
|
204
|
+
throw new StoreIntegrityError('object-corrupt', childDigest, `locked calls target '${target}' digest ${childDigest} is absent from every configured workflow store root`);
|
|
205
|
+
}
|
|
206
|
+
const selected = selectLockedTarget(target, childDigest, child);
|
|
207
|
+
// An alias is the only qualified path a parent calls: edge may take.
|
|
208
|
+
// All child workflows also retain an internal digest-scoped key so their
|
|
209
|
+
// bare sibling calls validate in the bundle that authored them.
|
|
210
|
+
if (child !== parent)
|
|
211
|
+
registerDependencyDefinitions(child);
|
|
212
|
+
validation.set(digestScopedCallsTargetKey(childDigest, target), selected);
|
|
213
|
+
await walkObject(child);
|
|
214
|
+
}
|
|
215
|
+
}
|
|
216
|
+
};
|
|
217
|
+
await walkObject(parent);
|
|
218
|
+
const finalized = finalizeDefs(validation);
|
|
219
|
+
const parentDefinitions = [...parent.defs.keys()].map((name) => finalized.get(name));
|
|
220
|
+
const cachedSupport = [...support.values()];
|
|
80
221
|
// Hub-backed orders use the immutable bundle digest as their execution
|
|
81
|
-
// identity.
|
|
82
|
-
//
|
|
83
|
-
// ambiguous step name instead of choosing one by manifest order.
|
|
222
|
+
// identity. Dependencies are validation-only: never cache or publish them
|
|
223
|
+
// under the parent digest, even when a child step name is globally unique.
|
|
84
224
|
if (requestedDigest === bundleDigest) {
|
|
85
|
-
cache.set(requestedDigest,
|
|
225
|
+
cache.set(requestedDigest, parentDefinitions.map((def) => ({
|
|
86
226
|
def,
|
|
87
227
|
bundleDigest,
|
|
88
|
-
objectPath,
|
|
228
|
+
objectPath: parent.objectPath,
|
|
229
|
+
support: cachedSupport,
|
|
89
230
|
})));
|
|
90
231
|
return true;
|
|
91
232
|
}
|
|
92
233
|
// Plain-YAML/local-engine orders retain the per-definition projection
|
|
93
234
|
// digest path for backwards compatibility.
|
|
94
|
-
for (const def of
|
|
235
|
+
for (const def of parentDefinitions) {
|
|
95
236
|
if (defInstructionDigest(def) === requestedDigest) {
|
|
96
|
-
cache.set(requestedDigest, [{
|
|
237
|
+
cache.set(requestedDigest, [{
|
|
238
|
+
def,
|
|
239
|
+
bundleDigest,
|
|
240
|
+
objectPath: parent.objectPath,
|
|
241
|
+
support: cachedSupport,
|
|
242
|
+
}]);
|
|
97
243
|
return true;
|
|
98
244
|
}
|
|
99
245
|
}
|
|
100
246
|
return false;
|
|
101
|
-
}
|
|
247
|
+
};
|
|
102
248
|
const candidateFailureForRefusal = (error) => error instanceof StoreIntegrityError && error.code === 'object-missing' ? undefined : error;
|
|
103
249
|
const scanTier = async (requestedDigest, bundleDigests, root, level) => {
|
|
104
250
|
let firstFailure;
|
|
@@ -118,11 +264,12 @@ export function createStoreInstructionSource(args) {
|
|
|
118
264
|
};
|
|
119
265
|
const evictObject = (bundleDigest, objectPath) => {
|
|
120
266
|
for (const [instructionDigest, cached] of cache) {
|
|
121
|
-
|
|
122
|
-
|
|
267
|
+
// A cached entry is valid only while EVERY object that supported its
|
|
268
|
+
// locked-edge closure is valid. Never leave a parent usable after a
|
|
269
|
+
// supporting child changes or disappears.
|
|
270
|
+
if (cached.some((candidate) => candidate.support.some((support) => support.bundleDigest === bundleDigest && support.objectPath === objectPath))) {
|
|
123
271
|
cache.delete(instructionDigest);
|
|
124
|
-
|
|
125
|
-
cache.set(instructionDigest, retained);
|
|
272
|
+
}
|
|
126
273
|
}
|
|
127
274
|
};
|
|
128
275
|
const verifyCached = async (requestedDigest) => {
|
|
@@ -131,23 +278,24 @@ export function createStoreInstructionSource(args) {
|
|
|
131
278
|
return false;
|
|
132
279
|
const verified = new Set();
|
|
133
280
|
for (const candidate of cached) {
|
|
134
|
-
const
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
281
|
+
for (const support of candidate.support) {
|
|
282
|
+
const key = `${support.root}:${support.bundleDigest}`;
|
|
283
|
+
if (verified.has(key))
|
|
284
|
+
continue;
|
|
285
|
+
verified.add(key);
|
|
286
|
+
try {
|
|
287
|
+
await coordinateDigestRead(support.root, support.bundleDigest, async () => {
|
|
288
|
+
const verify = args.verifier.verifyInstalledObjectAfterCoordination ?? args.verifier.verifyInstalledObject;
|
|
289
|
+
await verify.call(args.verifier, {
|
|
290
|
+
objectDir: support.objectPath,
|
|
291
|
+
digest: support.bundleDigest,
|
|
292
|
+
});
|
|
145
293
|
});
|
|
146
|
-
}
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
294
|
+
}
|
|
295
|
+
catch (error) {
|
|
296
|
+
evictObject(support.bundleDigest, support.objectPath);
|
|
297
|
+
throw error;
|
|
298
|
+
}
|
|
151
299
|
}
|
|
152
300
|
}
|
|
153
301
|
return true;
|
package/docs/bundles.md
CHANGED
|
@@ -75,7 +75,7 @@ The following rules apply:
|
|
|
75
75
|
- `runtime` is optional. When present, `runtime` is a closed mapping that contains `minVersion`, `features`, or both; `runtime: {}` is invalid. Runtime requirements are described in [Runtime compatibility](#runtime-compatibility).
|
|
76
76
|
- `workflows` is a non-empty map from workflow names to archive-relative YAML paths. Each workflow name matches `/^[a-z][a-z0-9-]*$/`. Each path must pass the canonical bundle path safety policy, and two workflow names may not point to the same path.
|
|
77
77
|
- A workflow file's `name:` must equal the workflow map key. For example, `workflows.delivery` must point to a file containing `name: delivery`.
|
|
78
|
-
- An installed workflow is addressable from `calls:` by the qualified name `<package>/<workflow>`. A bare `calls: <workflow>` inside a CAS-installed bundle is resolved to a sibling from that same bundle; it does not search unrelated bundles for a same-named workflow.
|
|
78
|
+
- An installed workflow is addressable from `calls:` by the qualified name `<package>/<workflow>`. A bare `calls: <workflow>` inside a CAS-installed bundle is resolved to a sibling from that same bundle; it does not search unrelated bundles for a same-named workflow. For local-engine coordinate discovery, an exact versioned `calls: namespace/name@version` resolves through the verified store-index coordinate to the bundle's selected default workflow, then the engine checks the matching `lock` digest before creating the child. A worker validates the same edge differently: it follows only the verified parent manifest's pinned lock digest to a locally verified CAS object and never uses coordinator-supplied child definition bytes.
|
|
79
79
|
- `default` is optional. When present, `default` must be one of the workflow map keys. When absent, a single-workflow package has that one workflow as its implicit default. A package with two or more workflows has no implicit default: the versioned coordinate is not registered as a callable target, while explicit `<package>/<workflow>` targets remain available.
|
|
80
80
|
- `platforms` is a duplicate-free list of portable selector strings. The list is advisory; platform policy is outside the package parser.
|
|
81
81
|
- `integrity.algorithm` is exactly `sha256`.
|
package/docs/cli.md
CHANGED
|
@@ -81,6 +81,9 @@ is independent of the `SEARCH INCOMPLETE` bounds notice.
|
|
|
81
81
|
| `capability bind <capability> <crew> [--hub <url>]` | add a crew to a workflow capability on the hub org — a capability may route to many crews (admin; human credential) — see [Capability routes](#capability-routes) |
|
|
82
82
|
| `capability unbind <capability> <crew> [--hub <url>]` | remove one `(capability, crew)` route — see [Capability routes](#capability-routes) |
|
|
83
83
|
| `capability list [--hub <url>]` | list the hub org's capability routes — see [Capability routes](#capability-routes) |
|
|
84
|
+
| `interface register <name> <version> --signature <file> [--hub <url>]` | register one immutable hub interface signature (admin; human credential) — see [Interface catalog](#interface-catalog) |
|
|
85
|
+
| `interface get <name> <version> [--hub <url>]` | get one exact interface signature from the hub — see [Interface catalog](#interface-catalog) |
|
|
86
|
+
| `interface list [--hub <url>]` | list every registered interface coordinate — see [Interface catalog](#interface-catalog) |
|
|
84
87
|
| `routing alerts [--workflow <wf>] [--limit <n>] [--hub <url>]` | list the hub org's routing alerts — every hold, reroute, wait and fallback the hub recorded — see [Routing](#routing) |
|
|
85
88
|
| `routing show <workflow> [--hub <url>]` | print one **hub run's** routing: modifier, wait policy, alerts, resolution reports and escalations — see [Routing](#routing) |
|
|
86
89
|
| `routing rule list [--hub <url>]` | list the org's capability **reroute rules**, in the order the hub tries them — see [Routing](#routing) |
|
|
@@ -2393,6 +2396,83 @@ needs a translation step.
|
|
|
2393
2396
|
| `2` | the hub couldn't be resolved (no `--hub` and not exactly one stored hub) |
|
|
2394
2397
|
| `3` | the human credential is missing or irrecoverable — the error names the remedy `owenloop login --hub <origin>` |
|
|
2395
2398
|
|
|
2399
|
+
## Interface catalog
|
|
2400
|
+
|
|
2401
|
+
The hub's interface catalog is an append-only registry of exact opaque
|
|
2402
|
+
`name@version` signatures. It is the operator surface for registering a
|
|
2403
|
+
breaking interface version before a workflow definition claims it. There is no
|
|
2404
|
+
update, delete, latest lookup, implementation index, or `x.implements` tooling:
|
|
2405
|
+
duplicate coordinates are refused and are never overwritten.
|
|
2406
|
+
|
|
2407
|
+
| command | method and endpoint | principal |
|
|
2408
|
+
|---|---|---|
|
|
2409
|
+
| `interface register <name> <version> --signature <file> [--hub <url>]` | `POST /api/register_interface` with `{name,version,signature}` | human; admin role required |
|
|
2410
|
+
| `interface get <name> <version> [--hub <url>]` | `GET /api/interfaces/:name/:version` | human; hub applies `get_status` |
|
|
2411
|
+
| `interface list [--hub <url>]` | `GET /api/interfaces` | human; hub applies `get_status` |
|
|
2412
|
+
|
|
2413
|
+
`get` encodes `<name>` and `<version>` separately as URL path segments, so a
|
|
2414
|
+
slash or space in either coordinate does not alter the route. The CLI does not
|
|
2415
|
+
validate coordinate syntax; the hub is the enforcement of record. At deployed
|
|
2416
|
+
hub SHA `d1dc2a1b02645ea6cf4eb4bf0319c3b917e137f4` (owenloop-service #263), the
|
|
2417
|
+
hub refuses a whole `.` or `..` name or version during registration with
|
|
2418
|
+
`interface_catalog_input_invalid`: those path segments normalize before the
|
|
2419
|
+
path-based exact-read route can address them. This is the only coordinate
|
|
2420
|
+
exception; ordinary dotted versions such as `evidence-report@2.0.0` round-trip
|
|
2421
|
+
through register, get, and list. The CLI sends all coordinates unchanged and
|
|
2422
|
+
does not add a local dot-segment guard or encoding workaround.
|
|
2423
|
+
|
|
2424
|
+
### Registering a signature
|
|
2425
|
+
|
|
2426
|
+
Pass a UTF-8 JSON file with `--signature`; a relative path is resolved from the
|
|
2427
|
+
current directory. For example, after reviewing a local file, use
|
|
2428
|
+
`owenloop interface register evidence-report 2.0.0 --signature interfaces/evidence-report-2.json --hub https://hub.example`.
|
|
2429
|
+
This is intentionally a file rather than the small inline JSON accepted by
|
|
2430
|
+
`start --provide name=json` and `provide --value json`: interface signatures
|
|
2431
|
+
can approach the hub's 64 KiB serialized limit and should be reviewable and
|
|
2432
|
+
reusable without shell quoting or argument-size concerns. It is also unlike
|
|
2433
|
+
`login --with-token`, which reads a secret from stdin; an interface signature is
|
|
2434
|
+
non-secret structured data.
|
|
2435
|
+
|
|
2436
|
+
The CLI reads the file and runs `JSON.parse` only. It sends the resulting value
|
|
2437
|
+
unchanged and delegates coordinate validity, signature shape, typed artifacts,
|
|
2438
|
+
JSON Schemas, duplicate artifact names, and size validation entirely to the
|
|
2439
|
+
hub. A syntactically valid but semantically invalid signature—or a whole `.` or
|
|
2440
|
+
`..` coordinate—therefore reaches the hub and surfaces its non-empty error
|
|
2441
|
+
message; an unreadable or invalid-JSON file fails before a network call.
|
|
2442
|
+
|
|
2443
|
+
### Reading and output
|
|
2444
|
+
|
|
2445
|
+
`get` and successful `register` return the full opaque signature for one exact
|
|
2446
|
+
coordinate. `list` preserves hub order and deliberately returns signature-free
|
|
2447
|
+
rows, so listing a catalog does not transfer every signature body. stdout is
|
|
2448
|
+
exactly one whitelisted JSON document per successful invocation; the hub's
|
|
2449
|
+
`text` field and unknown response fields are never printed.
|
|
2450
|
+
|
|
2451
|
+
| command | stdout |
|
|
2452
|
+
|---|---|
|
|
2453
|
+
| `interface register` / `interface get` | `{ "ok": true, "hub": "<origin>", "name": "evidence-report", "version": "2.0.0", "signature": { … }, "createdBy": "<id>", "createdAt": 1738000000000 }` |
|
|
2454
|
+
| `interface list` | `{ "ok": true, "hub": "<origin>", "interfaces": [{ "name": "evidence-report", "version": "2.0.0", "createdBy": "<id>", "createdAt": 1738000000000 }] }` |
|
|
2455
|
+
|
|
2456
|
+
Malformed 2xx bodies are rejected before printing. Typed hub refusals such as
|
|
2457
|
+
a duplicate/invalid registration (`400 interface_catalog_input_invalid`),
|
|
2458
|
+
non-admin register (`403 forbidden`), and an unknown exact coordinate (`404
|
|
2459
|
+
interface_catalog_not_found`) surface only the hub's non-empty `message` on
|
|
2460
|
+
stderr and leave stdout empty; the CLI does not prefix it with an `error` code.
|
|
2461
|
+
|
|
2462
|
+
**Hub and credential selection.** All three commands resolve `--hub <url>`
|
|
2463
|
+
first; without it they require exactly one enumerable stored human hub. They do
|
|
2464
|
+
not default from `OWENLOOP_HUB` or a production origin. The human credential slot
|
|
2465
|
+
is used for every command. `OWENLOOP_CREDENTIAL_COMMAND` is supported because
|
|
2466
|
+
this namespace stores no credential locally; an external backend that cannot
|
|
2467
|
+
enumerate hubs must receive `--hub` explicitly.
|
|
2468
|
+
|
|
2469
|
+
| code | meaning |
|
|
2470
|
+
|---|---|
|
|
2471
|
+
| `0` | registered, read, or listed successfully |
|
|
2472
|
+
| `1` | runtime, hub, or malformed-response error, including a hub-side registration refusal |
|
|
2473
|
+
| `2` | the hub could not be resolved |
|
|
2474
|
+
| `3` | the human credential is missing or irrecoverable; stderr names `owenloop login --hub <origin>` |
|
|
2475
|
+
|
|
2396
2476
|
## Routing
|
|
2397
2477
|
|
|
2398
2478
|
`owenloop routing` reads and edits the hub's **live routing** state — what the
|
package/docs/design.md
CHANGED
|
@@ -1875,10 +1875,21 @@ operation required by `OrderResolver`:
|
|
|
1875
1875
|
is loaded. A project object that exists but is corrupt is an integrity
|
|
1876
1876
|
refusal; it is not hidden by a valid global copy.
|
|
1877
1877
|
3. The source reads the verified object's `bundle.yaml`, loads every workflow
|
|
1878
|
-
path listed in the `workflows` map,
|
|
1879
|
-
|
|
1880
|
-
|
|
1881
|
-
|
|
1878
|
+
path listed in the `workflows` map, and attaches its package, digest, and
|
|
1879
|
+
copied manifest lock as CAS provenance. For every exact versioned
|
|
1880
|
+
`calls:` edge, it follows only that verified manifest's lock digest,
|
|
1881
|
+
verifies the exact child object with the same installed-object verifier,
|
|
1882
|
+
resolves the child's explicit default (or its sole workflow), and repeats
|
|
1883
|
+
recursively. It strictly finalizes the combined private map, so child
|
|
1884
|
+
inputs, output shape, and cross-bundle cycles remain executable-time
|
|
1885
|
+
validations rather than deferred assumptions.
|
|
1886
|
+
4. The cache exposes only definitions originating in the requested object; a
|
|
1887
|
+
dependency is never addressable through its parent's digest. Each cache entry
|
|
1888
|
+
records every verified supporting object, and a later `prime` re-verifies
|
|
1889
|
+
that entire support set, evicting every dependent cached parent on a failure.
|
|
1890
|
+
The source then computes each requested-object instruction projection digest
|
|
1891
|
+
and caches the matching definition when one equals the order's `defDigest`.
|
|
1892
|
+
5. `lookup` then serves the cached step's authored body and command bytes. A
|
|
1882
1893
|
cache miss is `unknown-digest`; a known digest with no matching step is
|
|
1883
1894
|
`unknown-step`.
|
|
1884
1895
|
|
package/docs/embedding.md
CHANGED
|
@@ -137,9 +137,13 @@ const instructions = resolver.resolveOrder(order); // synchronous cache lookup
|
|
|
137
137
|
|
|
138
138
|
`prime` returns `resolved` or `unknown-digest`; an integrity failure is a
|
|
139
139
|
separate refusal. The source enumerates indexed bundle objects, verifies each
|
|
140
|
-
candidate on read,
|
|
141
|
-
|
|
142
|
-
|
|
140
|
+
candidate on read, and for an exact versioned `calls:` edge follows only the
|
|
141
|
+
digest in that verified parent's manifest lock. Each pinned child is verified
|
|
142
|
+
before its workflow bytes are read; the combined closure is finalized strictly,
|
|
143
|
+
but only definitions from the requested object enter the instruction cache.
|
|
144
|
+
Later primes re-verify every object supporting that closure. The source matches
|
|
145
|
+
each requested definition's instruction projection digest to `order.defDigest`.
|
|
146
|
+
The order's digest is the
|
|
143
147
|
only instruction key supplied by the transport; the source never accepts
|
|
144
148
|
prompt or command text from the packet. `createEngine` keeps its default
|
|
145
149
|
loaded-definition emitter, because the store source's `digestOf` is deliberately
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "owenloop",
|
|
3
|
-
"version": "0.5.
|
|
3
|
+
"version": "0.5.21",
|
|
4
4
|
"description": "Deterministic rails for agentic workflows. Declare steps and dependencies; the engine guarantees order, redoes what changes invalidate, and stops what keeps failing — instead of hoping the agent follows through.",
|
|
5
5
|
"license": "Apache-2.0",
|
|
6
6
|
"author": "typicalday",
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "owenloop",
|
|
3
|
-
"version": "0.5.
|
|
3
|
+
"version": "0.5.21",
|
|
4
4
|
"description": "Claude Code driver for owenloop — cross-harness shift and conduct skills driven by the owenloop CLI, plus one hub control-plane MCP server backing an author skill and a fallback worker, for conducting and authoring workflows against your hosted owenloop server.",
|
|
5
5
|
"author": {
|
|
6
6
|
"name": "Typical Day"
|