git mv packages/business -> packages/organization (@mosaic/organization). The old package stays as one-line re-export shims of each moved module, with src/business.mjs re-exporting src/organization-config.mjs and src/cli.mjs forwarding to the moved executable. BusinessError is OrganizationConfigError (one constructor, name kept BusinessError); OrganizationError stays distinct. The bus adapter gains organization-context.mjs (busOrganization), with business.mjs (busBusiness) as the same function. Import consumers, manifests, the lockfile, scripts/mosaic, stack-copy.sh COPY_PATHS (both roots), seat sandbox RUNNER_FILES and the copy closure walker (organization-imports.mjs, both roots required) move to the new path. v1 serialization, v1 writers and the stage A fixtures are unchanged; the stage A contract tests stay where they were and pass as before.
118 lines
5.6 KiB
JavaScript
118 lines
5.6 KiB
JavaScript
// The resolver (REQ-VAR-1 and 2). It joins one role instance's definition,
|
|
// the business file, the optional project file and the system config into
|
|
// the record a launcher or the broker uses. Plain values: the most specific
|
|
// layer wins. Limits: every layer narrows, nothing widens.
|
|
|
|
import { refuse } from "./errors.mjs";
|
|
import { ACTIONS, NETWORKS, isHostKind } from "./vocabulary.mjs";
|
|
import { checkVars, mergeVars } from "./vars.mjs";
|
|
import { canonicalJson, sha256, deepFreeze } from "./util.mjs";
|
|
import { projectFilePath } from "./project.mjs";
|
|
|
|
// The system layer from `mosaic-config.mjs validate` output.
|
|
export function systemVars(config) {
|
|
return checkVars({
|
|
environment: config.environment,
|
|
dataRoot: config.dataRoot,
|
|
"execution.backend": config.execution.backend,
|
|
"execution.provider": config.execution.provider,
|
|
"execution.model": config.execution.model,
|
|
"execution.adapter": config.execution.adapter,
|
|
}, "system", "system config");
|
|
}
|
|
|
|
function narrowerNetwork(a, b) {
|
|
return NETWORKS.indexOf(a) <= NETWORKS.indexOf(b) ? a : b;
|
|
}
|
|
|
|
// resolveInstance({ system, business, project, instance })
|
|
// system systemVars(...) output
|
|
// business loadBusiness(...) output
|
|
// project loadProject(...) output, or null
|
|
// instance a role instance the business file declares
|
|
export function resolveInstance({ system, business, project = null, instance }) {
|
|
const entry = Object.hasOwn(business.roles, instance) ? business.roles[instance] : null;
|
|
if (!entry) refuse(`business ${business.id} declares no role instance ${JSON.stringify(instance)}`);
|
|
const definition = business.definitions[entry.definition];
|
|
|
|
const layers = [
|
|
{ layer: "system", source: "system", vars: system },
|
|
{ layer: "business", source: `business:${business.id}`, vars: business.vars },
|
|
];
|
|
let projectId = null;
|
|
if (project) {
|
|
const declared = Object.entries(business.projects).find(([, p]) => p.kind !== 'library' && projectFilePath(p.root) === project.file);
|
|
if (!declared || declared[0] !== project.id) {
|
|
refuse(`project ${project.id} (${project.file}) isn't declared under that id in business ${business.id}`);
|
|
}
|
|
projectId = project.id;
|
|
for (const name of Object.keys(project.roles)) {
|
|
if (!Object.hasOwn(business.roles, name)) refuse(`project ${project.id} sets vars for role instance ${name}, which business ${business.id} doesn't declare`);
|
|
}
|
|
layers.push({ layer: "project", source: `project:${project.id}`, vars: project.vars });
|
|
if (Object.hasOwn(project.roles, instance)) {
|
|
layers.push({ layer: "project", source: `project:${project.id}:roles.${instance}`, vars: project.roles[instance].vars });
|
|
}
|
|
}
|
|
layers.push({ layer: "agent", source: `business:${business.id}:roles.${instance}`, vars: entry.vars });
|
|
const { vars, provenance } = mergeVars(layers);
|
|
|
|
let tools = [...definition.tools];
|
|
let network = definition.network;
|
|
let withinRole = [...definition.authority.withinRole];
|
|
let crossRole = [...definition.authority.crossRole];
|
|
if (vars["limits.tools"]) tools = tools.filter((t) => vars["limits.tools"].includes(t));
|
|
if (vars["limits.network"]) network = narrowerNetwork(network, vars["limits.network"]);
|
|
if (vars["limits.authority"]) {
|
|
withinRole = withinRole.filter((a) => vars["limits.authority"].includes(a));
|
|
crossRole = crossRole.filter((a) => vars["limits.authority"].includes(a));
|
|
}
|
|
// role.launch needs the business file's launch block naming this
|
|
// instance (addendum A section 8), and the verb must survive
|
|
// limits.authority. Otherwise the verb is gated and `launch` is null,
|
|
// so the two never disagree.
|
|
const launch = business.launch && business.launch.by === instance && withinRole.includes("role.launch") ? business.launch : null;
|
|
if (!launch) {
|
|
withinRole = withinRole.filter((a) => a !== "role.launch");
|
|
crossRole = crossRole.filter((a) => a !== "role.launch");
|
|
}
|
|
|
|
const resolved = {
|
|
business: business.id,
|
|
project: projectId,
|
|
instance,
|
|
definition: definition.name,
|
|
holder: entry.holder,
|
|
contract: definition.contractPath,
|
|
vars,
|
|
provenance,
|
|
limits: { tools, network, authority: { withinRole, crossRole } },
|
|
// Row 210 (#1707, design D5): a host key is used only by the bus child, never by the session,
|
|
// so it stays out of the session's credentials and the harness's needs.
|
|
credentials: Object.fromEntries(Object.entries(entry.credentials).filter(([kind]) => !isHostKind(kind))),
|
|
tracker: entry.tracker,
|
|
launch,
|
|
// #797 relay R2: an owner-started assistant cannot infer its coordinator
|
|
// from launchedBy or running claims. Only the validated business chooses
|
|
// this address; it grants no launch authority or messaging exception.
|
|
...(definition.name === "assistant" ? { coordinator: business.launch ? {
|
|
instance: business.launch.by,
|
|
name: business.roles[business.launch.by].identity?.name ?? null,
|
|
} : null } : {}),
|
|
// REQ-HARN-2: the search-source plug-in the organization file switches on, by name.
|
|
webSource: business.plugins?.["search-source"] ?? null,
|
|
// The role file's skill names. The bundle resolves each against <dataRoot>/skills-enabled.
|
|
skills: [...definition.skills],
|
|
};
|
|
return deepFreeze({ ...resolved, digest: sha256(canonicalJson(resolved)) });
|
|
}
|
|
|
|
// Classify one action for a resolved instance: "within", "cross" or
|
|
// "gated". An action outside the vocabulary refuses.
|
|
export function classify(resolved, action) {
|
|
if (!ACTIONS.includes(action)) refuse(`unknown action: ${JSON.stringify(action)}`);
|
|
if (resolved.limits.authority.withinRole.includes(action)) return "within";
|
|
if (resolved.limits.authority.crossRole.includes(action)) return "cross";
|
|
return "gated";
|
|
}
|