witnora 0.10.3 → 0.10.4

package/README.md

@@ -26,6 +26,20 @@ boundary, writes only missing configuration, and verifies the local evidence
 path. `.witnora/onboarding/receipt.json` is synthetic: it cannot create a run,
 evidence object, release decision, or `CURRENT` assurance.
 
+Onboarding also performs the default private capability discovery locally. It
+does not read source-file contents or upload source code, prompt text,
+credentials, tool inputs, tool outputs, database rows, or file contents. It
+uploads a signed snapshot containing generalized capability metadata and
+digests. Refresh it later with:
+
+```bash
+npx witnora@latest discover
+```
+
+Customers that do not permit repository metadata inspection can choose
+runtime-only discovery in Hosted. Source-assisted analysis is a separate,
+explicit GitHub authorization and is never enabled implicitly.
+
 After the connection self-test, Hosted shows one template-specific next step.
 Place the generated boundary in one meaningful sandbox workflow and run it
 normally. The generated local adapter reuses the saved restricted connection;

package/dist/cli.js

@@ -36,6 +36,8 @@ import { runAssuranceLoopDemo } from "./assurance-loop-demo.js";
 import { importGenericEval, renderGenericEvalReport } from "./generic-eval.js";
 import { runDesignPartnerCommand } from "./design-partner-v02.js";
 import { runOnboard } from "./onboard.js";
+import { inspectRepository } from "./onboard.js";
+import { runPrivateCapabilityDiscovery } from "./private-discovery.js";
 import { verifyEvidencePacketV02 } from "./evidence-v02.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
@@ -155,6 +157,21 @@ else if (command === "onboard") {
         openBrowser: readBoolFlag("--no-browser") ? async () => { } : undefined,
     });
 }
+else if (command === "discover") {
+    const connectionName = readFlag("--connection");
+    const connection = await resolveConnection({
+        name: connectionName,
+        server: readFlag("--server"),
+        projectId: readFlag("--project"),
+        apiKey: readFlag("--api-key"),
+    });
+    const repositoryPath = resolve(readFlag("--repo") ?? process.cwd());
+    const repository = await inspectRepository(repositoryPath, readFlag("--template") ? parseAgentTemplate(readFlag("--template")) : undefined);
+    const result = await runPrivateCapabilityDiscovery({ connection, repository, connectionName: connectionName ?? repository.slug });
+    process.stdout.write(`Private capability discovery completed.\n`);
+    process.stdout.write(`Capability groups: ${result.capabilityCount}\nUnknown groups awaiting review: ${result.unknownCapabilityCount}\n`);
+    process.stdout.write("Uploaded: signed capability metadata and digests only.\nStayed local: source code, prompts, credentials, tool inputs and outputs, database rows, and file contents.\n");
+}
 else if (command === "try") {
     const template = parseAgentTemplate(readFlag("--template") ?? "workflow");
     const subject = readFlag("--subject") ?? `witnora-sample-${template}`;

package/dist/command-help.js

@@ -1,6 +1,21 @@
 export function renderCommandHelp(command) {
     if (command === "sandbox" || command === "browser-adapter")
         return undefined;
+    if (command === "discover")
+        return `Usage:
+  witnora discover [--connection <name>] [--repo <directory>]
+
+Runs capability discovery inside the customer environment and uploads only a signed,
+metadata-only snapshot. Source code, prompt text, credentials, tool inputs and outputs,
+database rows, and file contents are not uploaded. New capability groups remain pending
+until reviewed or observed through a controlled runtime boundary.
+
+Options:
+  --connection <name>     Saved Hosted connection (default: current connection)
+  --repo <directory>      Repository whose local metadata is inspected (default: current directory)
+  --template <type>       Optional repository-type hint
+  --help, -h              Show this help
+`;
     if (command === "onboard")
         return `Usage:
   witnora onboard --project <project-id>

package/dist/onboard.js

@@ -4,6 +4,7 @@ import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { DEFAULT_WITNORA_SERVER, saveConnection } from "./credentials.js";
 import { verifyControlPlaneConnection } from "./control-plane.js";
+import { inferPrivateCapabilities, runPrivateCapabilityDiscovery } from "./private-discovery.js";
 import { parseAgentTemplate, starterAdapter, starterInstructions, starterProfile, starterTripwireConfig } from "./onboarding-templates.js";
 import { writeTryEvidence } from "./try.js";
 export async function runOnboard(options) {
@@ -43,13 +44,21 @@ export async function runOnboard(options) {
     const receiptPath = join(repositoryPath, ".witnora", "onboarding", "receipt.json");
     await mkdir(dirname(receiptPath), { recursive: true });
     await writeFile(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`);
+    const discovery = await runPrivateCapabilityDiscovery({
+        connection: { server, projectId: token.projectId, apiKey: token.apiKey },
+        repository,
+        connectionName: token.connectionName,
+        configHome: options.configHome,
+        fetch: requestFetch,
+    });
     output(`\nConnected ${repository.name} to Witnora.\n`);
     output(`Project: ${token.projectId}\nTemplate: ${repository.template} (${repository.kind})\n`);
     output(`Credentials: ${credentialsPath}\nSelf-test receipt: ${receiptPath}\n`);
+    output(`Private discovery: ${discovery.capabilityCount} capability group(s); source code, prompts, credentials, and payloads stayed local.\n`);
     output("The synthetic self-test verified the local evidence path. It did not create a run, evidence object, release decision, or CURRENT assurance.\n");
     output(starterInstructions(repository.template, repository.name));
     return { projectId: token.projectId, connectionName: token.connectionName, credentialsPath, template: repository.template,
-        repositoryKind: repository.kind, generatedFiles, receiptPath };
+        repositoryKind: repository.kind, generatedFiles, receiptPath, discovery };
 }
 async function waitForToken(requestFetch, server, device, codeVerifier, sleep, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
@@ -66,7 +75,7 @@ async function waitForToken(requestFetch, server, device, codeVerifier, sleep, t
     }
     throw new Error("Device authorization timed out. Run witnora onboard again to create a new one-time request.");
 }
-async function inspectRepository(repositoryPath, explicitTemplate) {
+export async function inspectRepository(repositoryPath, explicitTemplate) {
     const entries = await readdir(repositoryPath, { withFileTypes: true });
     const names = entries.map((entry) => entry.name).sort();
     const packageJson = await optionalJson(join(repositoryPath, "package.json"));
@@ -82,7 +91,13 @@ async function inspectRepository(repositoryPath, explicitTemplate) {
     const name = rawName.replace(/^@[^/]+\//, "") || "agent-repository";
     const slug = (name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "agent-repository").slice(0, 64);
     const fingerprintSha256 = createHash("sha256").update(JSON.stringify({ kind, name, files: names.filter((value) => !value.startsWith(".")).slice(0, 200) })).digest("hex");
-    return { kind, name, slug, template, fingerprintSha256 };
+    const dependencyNames = packageJson ? [
+        ...Object.keys(record(packageJson.dependencies)),
+        ...Object.keys(record(packageJson.devDependencies)),
+        ...Object.keys(record(packageJson.peerDependencies)),
+    ] : [];
+    const capabilities = inferPrivateCapabilities({ dependencyNames, topLevelNames: names });
+    return { kind, name, slug, template, fingerprintSha256, capabilities };
 }
 async function generateRepositoryConfig(repositoryPath, template, subject) {
     const files = new Map();
@@ -131,3 +146,6 @@ catch {
     return false;
 } }
 function normalizeServer(value) { return new URL(value).toString().replace(/\/$/, ""); }
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}

package/dist/private-discovery.js

@@ -0,0 +1,146 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from "node:crypto";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export async function runPrivateCapabilityDiscovery(input) {
+    const requestFetch = input.fetch ?? fetch;
+    const request = await jsonRequest(requestFetch, `${input.connection.server}/v1/projects/${encodeURIComponent(input.connection.projectId)}/private-discovery`, {
+        method: "POST",
+        headers: authorization(input.connection.apiKey),
+        body: JSON.stringify({ mode: "private_discovery" }),
+    });
+    const identityPath = discoveryIdentityPath(input.connection.projectId, input.configHome);
+    const identity = await loadOrCreateIdentity(identityPath, input.connection.projectId, input.connectionName);
+    const payload = {
+        schemaVersion: "witnora.private_capability_snapshot.v0.1",
+        requestId: request.id,
+        projectId: input.connection.projectId,
+        challenge: request.challenge,
+        collectorId: `private-discovery:${safeIdentifier(input.connectionName)}`,
+        mode: "private_discovery",
+        generatedAt: new Date().toISOString(),
+        repository: {
+            kind: input.repository.kind,
+            name: `repository-${input.repository.fingerprintSha256.slice(0, 12)}`,
+            fingerprintSha256: input.repository.fingerprintSha256,
+        },
+        privacy: {
+            sourceCodeUploaded: false,
+            rawPromptsUploaded: false,
+            credentialsUploaded: false,
+            payloadsUploaded: false,
+            localRedactionApplied: true,
+        },
+        capabilities: input.repository.capabilities,
+        unknownCapabilityCount: input.repository.capabilities.length,
+    };
+    const payloadSha256 = sha256(canonicalJson(payload));
+    const privateKey = createPrivateKey(identity.privateKeyPem);
+    const publicKey = createPublicKey(identity.publicKeyPem);
+    const snapshot = {
+        payload,
+        payloadSha256,
+        source: {
+            algorithm: "Ed25519",
+            keyId: identity.keyId,
+            publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+            publicKeySha256: sha256(publicKey.export({ type: "spki", format: "der" })),
+            signature: sign(null, Buffer.from(payloadSha256), privateKey).toString("base64url"),
+        },
+    };
+    const completed = await jsonRequest(requestFetch, `${input.connection.server}/v1/projects/${encodeURIComponent(input.connection.projectId)}/private-discovery/${encodeURIComponent(request.id)}/complete`, {
+        method: "POST",
+        headers: authorization(input.connection.apiKey),
+        body: JSON.stringify(snapshot),
+    });
+    return {
+        requestId: completed.id,
+        capabilityCount: input.repository.capabilities.length,
+        unknownCapabilityCount: completed.snapshot?.payload?.unknownCapabilityCount ?? input.repository.capabilities.length,
+        identityPath,
+    };
+}
+export function inferPrivateCapabilities(input) {
+    const searchable = [...input.dependencyNames, ...input.topLevelNames].join(" ").toLowerCase();
+    const detected = new Map();
+    const add = (key, observedName, transport) => detected.set(key, {
+        key,
+        observedName,
+        transport,
+        disposition: "pending",
+        schemaSha256: sha256(canonicalJson({ key, observedName, transport, source: "repository_metadata" })),
+        source: "repository_metadata",
+    });
+    add("workflow:orchestration", "Workflow orchestration", "workflow");
+    if (/playwright|puppeteer|browser-use|stagehand|selenium|computer-use/.test(searchable))
+        add("browser:automation", "Browser automation", "browser");
+    if (/modelcontextprotocol|(^|[^a-z])mcp([^a-z]|$)/.test(searchable))
+        add("mcp:tool-calling", "MCP tool calling", "mcp");
+    if (/axios|undici|node-fetch|httpx|requests|express|fastapi|fetch/.test(searchable))
+        add("http:tool-calling", "HTTP tool calling", "http");
+    if (/codex|aider|coding-agent|swe-agent|openhands/.test(searchable))
+        add("coding:workspace", "Coding workspace", "coding");
+    if (/pandas|duckdb|prisma|sequelize|sqlalchemy|postgres|sqlite|(^|[^a-z])(pg|sql)([^a-z]|$)/.test(searchable))
+        add("data:structured", "Structured data access", "data");
+    if (/slack|discord|twilio|resend|sendgrid|postmark|nodemailer|email/.test(searchable))
+        add("messaging:external", "External messaging", "messaging");
+    return [...detected.values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+function discoveryIdentityPath(projectId, configHome) {
+    const root = configHome ?? process.env.WITNORA_CONFIG_HOME ?? process.env.AGENTCERT_CONFIG_HOME
+        ?? join(process.env.USERPROFILE ?? process.env.HOME ?? ".", ".witnora");
+    return join(root, "private-discovery", `${safeIdentifier(projectId)}.json`);
+}
+async function loadOrCreateIdentity(path, projectId, connectionName) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!parsed.keyId || !parsed.privateKeyPem || !parsed.publicKeyPem)
+            throw new Error("identity fields are missing");
+        return parsed;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw new Error(`Witnora private discovery identity is invalid: ${path}`);
+    }
+    const pair = generateKeyPairSync("ed25519");
+    const identity = {
+        keyId: `discovery:${safeIdentifier(connectionName)}:${sha256(projectId).slice(0, 12)}`,
+        privateKeyPem: pair.privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+        publicKeyPem: pair.publicKey.export({ type: "spki", format: "pem" }).toString(),
+    };
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(identity, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(temporary, path);
+    await chmod(path, 0o600).catch(() => undefined);
+    return identity;
+}
+function authorization(apiKey) {
+    return { authorization: `Bearer ${apiKey}`, "content-type": "application/json" };
+}
+async function jsonRequest(requestFetch, url, init) {
+    const response = await requestFetch(url, init);
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error(String(body.error ?? `${init.method ?? "GET"} ${url} failed with HTTP ${response.status}.`));
+    return body;
+}
+function safeIdentifier(value) {
+    return value.trim().replace(/[^A-Za-z0-9._:-]+/g, "-").replace(/^-|-$/g, "").slice(0, 120) || "local";
+}
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("Canonical JSON does not support non-finite numbers.");
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+    throw new Error("Canonical JSON contains an unsupported value.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "witnora",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Independent assurance for covered agent action paths across models and frameworks.",
   "type": "module",
   "license": "Apache-2.0",