@kaddo/cli 3.82.0 → 3.83.0

package/dist/index.js

@@ -17381,7 +17381,7 @@ async function runTopologyApply(file, opts = {}) {
 
 // src/services/integrations.ts
 import matter11 from "gray-matter";
-import { parse as parseYaml17 } from "yaml";
+import { parse as parseYaml17, stringify as stringifyYaml8 } from "yaml";
 
 // src/core/work-item-write.ts
 import fs4 from "fs";
@@ -17636,6 +17636,26 @@ function parseCredentials(raw, id, findings) {
   }
   return creds;
 }
+function parseSecrets(raw, id, findings) {
+  const secrets = {};
+  if (raw == null) return secrets;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    findings.push({ level: "blocking", id, message: `Integration "${id}": secrets must be a mapping of logical references.` });
+    return secrets;
+  }
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string" && value.trim()) {
+      if (value.length > 100 || /^(ghp_|sk-|xox[bpsa]-|glpat-|ey[A-Za-z0-9])/i.test(value)) {
+        findings.push({ level: "blocking", id, message: `Integration "${id}": secret "${key}" appears to contain an actual credential, not a reference name.` });
+        continue;
+      }
+      secrets[key] = value.trim();
+    } else {
+      findings.push({ level: "warning", id, message: `Integration "${id}": ignoring non-string secret entry "${key}".` });
+    }
+  }
+  return secrets;
+}
 function parseIntegrationsConfig(raw, opts) {
   const findings = [];
   const integrations = [];
@@ -17668,12 +17688,13 @@ function parseIntegrationsConfig(raw, opts) {
     const enabled = o.enabled === void 0 ? true : o.enabled === true || o.enabled === "true";
     const config = o.config && typeof o.config === "object" && !Array.isArray(o.config) ? o.config : {};
     const credentials = parseCredentials(o.credentials, id, findings);
+    const secrets = parseSecrets(o.secrets, id, findings);
     const timeoutMs = typeof o.timeout_ms === "number" ? o.timeout_ms : typeof o.timeoutMs === "number" ? o.timeoutMs : void 0;
-    integrations.push({ id, adapter, enabled, config, credentials, timeoutMs });
+    integrations.push({ id, adapter, enabled, config, credentials, secrets, timeoutMs });
   }
   return { integrations, findings };
 }
-function resolveCredentials(integration, env) {
+async function resolveAllCredentials(integration, resolver, env) {
   const credentials = {};
   const missing = [];
   for (const [name, ref] of Object.entries(integration.credentials)) {
@@ -17681,6 +17702,12 @@ function resolveCredentials(integration, env) {
     if (value && value.length > 0) credentials[name] = value;
     else missing.push(ref.env);
   }
+  for (const [name, ref] of Object.entries(integration.secrets)) {
+    if (credentials[name]) continue;
+    const value = await resolver.resolve(ref);
+    if (value !== void 0) credentials[name] = value;
+    else missing.push(ref);
+  }
   return { credentials, missing };
 }
 
@@ -17705,6 +17732,82 @@ function buildImportPreview(item, opts) {
   };
 }
 
+// ../integrations/src/secrets.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2, unlinkSync } from "fs";
+import { dirname as dirname2 } from "path";
+var SECRETS_FILENAME = ".secrets.json";
+function secretsPath(projectDir) {
+  return `${projectDir}/.kaddo/${SECRETS_FILENAME}`;
+}
+function loadStore(filePath) {
+  if (!existsSync2(filePath)) return {};
+  try {
+    const raw = readFileSync2(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    return {};
+  } catch {
+    return {};
+  }
+}
+function saveStore(filePath, store) {
+  mkdirSync(dirname2(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(store, null, 2) + "\n", "utf-8");
+}
+function createLocalSecretProvider(projectDir) {
+  const fp = secretsPath(projectDir);
+  return {
+    async get(key) {
+      const store = loadStore(fp);
+      const val = store[key];
+      return val !== void 0 && val !== "" ? val : void 0;
+    },
+    async set(key, value) {
+      const store = loadStore(fp);
+      store[key] = value;
+      saveStore(fp, store);
+    },
+    async delete(key) {
+      const store = loadStore(fp);
+      delete store[key];
+      saveStore(fp, store);
+    },
+    async exists(key) {
+      const store = loadStore(fp);
+      return key in store && store[key] !== void 0 && store[key] !== "";
+    }
+  };
+}
+function createEnvSecretProvider(env = process.env) {
+  return {
+    async get(key) {
+      const val = env[key];
+      return val !== void 0 && val !== "" ? val : void 0;
+    },
+    async set() {
+      throw new Error("Environment secret provider is read-only.");
+    },
+    async delete() {
+      throw new Error("Environment secret provider is read-only.");
+    },
+    async exists(key) {
+      const val = env[key];
+      return val !== void 0 && val !== "";
+    }
+  };
+}
+function createCompositeResolver(...providers) {
+  return {
+    async resolve(reference) {
+      for (const provider of providers) {
+        const val = await provider.get(reference);
+        if (val !== void 0) return val;
+      }
+      return void 0;
+    }
+  };
+}
+
 // ../integrations/src/registry.ts
 var DuplicateAdapterError = class extends Error {
   constructor(id) {
@@ -17789,7 +17892,31 @@ function createMockAdapter(opts = {}) {
       id: MOCK_ADAPTER_ID,
       displayName: "Mock Work Source",
       version: "1.0.0",
-      description: "Deterministic offline reference adapter for validating the integration foundation."
+      description: "Deterministic offline reference adapter for validating the integration foundation.",
+      configSchema: {
+        simulate: {
+          type: "select",
+          required: false,
+          label: "Simulation mode",
+          description: "Controls what the mock adapter simulates during verify/read operations.",
+          options: [
+            { value: "available", label: "Available" },
+            { value: "unauthorized", label: "Unauthorized" },
+            { value: "rate-limited", label: "Rate Limited" },
+            { value: "unavailable", label: "Unavailable" },
+            { value: "timeout", label: "Timeout" }
+          ],
+          defaultValue: "available"
+        }
+      },
+      secretSchema: {
+        token: {
+          type: "string",
+          required: false,
+          label: "API Token",
+          description: "Optional token for testing secret handling (not used by the mock adapter)."
+        }
+      }
     },
     capabilities: {
       workItems: { list: true, read: true, import: true, write: false, statusSync: false, comments: false, webhooks: false }
@@ -17866,6 +17993,9 @@ function configStatus(integration, findings) {
   if (blocking || !registry.has(integration.adapter)) return "invalid-config";
   return "configured";
 }
+function secretResolver(dir, env) {
+  return createCompositeResolver(createLocalSecretProvider(dir), createEnvSecretProvider(env));
+}
 function listIntegrations(dir) {
   const { integrations, findings } = loadIntegrations(dir);
   return integrations.map((integration) => {
@@ -17879,6 +18009,8 @@ function listIntegrations(dir) {
       capabilities: adapter?.capabilities ?? null,
       metadata: adapter?.metadata ?? null,
       credentialRefs: Object.values(integration.credentials).map((c) => c.env),
+      secretRefs: Object.values(integration.secrets),
+      secretStatus: {},
       findings: findings.filter((f) => f.id === integration.id)
     };
   });
@@ -17887,15 +18019,16 @@ function requireIntegration(dir, id) {
   const { integrations, findings } = loadIntegrations(dir);
   const integration = integrations.find((i) => i.id === id);
   if (!integration) throw new IntegrationServiceError("INTEGRATION_NOT_CONFIGURED", `No integration "${id}" is configured in this project.`);
-  return { integration, findings };
+  return { integration, findings, all: integrations };
 }
 function resolveAdapter(integration) {
   const adapter = registry.get(integration.adapter);
   if (!adapter) throw new IntegrationServiceError("ADAPTER_NOT_FOUND", `Unknown integration adapter "${integration.adapter}".`);
   return adapter;
 }
-function buildContext(integration, env) {
-  const { credentials, missing } = resolveCredentials(integration, env);
+async function buildContextWithSecrets(dir, integration, env) {
+  const resolver = secretResolver(dir, env);
+  const { credentials, missing } = await resolveAllCredentials(integration, resolver, env);
   return {
     context: { integrationId: integration.id, config: integration.config, credentials, timeoutMs: integration.timeoutMs ?? DEFAULT_TIMEOUT_MS },
     missing
@@ -17918,7 +18051,7 @@ async function verifyIntegration(dir, id, env = process.env) {
   if (cfgStatus === "disabled") return { id, status: "disabled", connection: null, missingCredentials: [] };
   if (cfgStatus === "invalid-config") return { id, status: "invalid-config", connection: null, missingCredentials: [] };
   const adapter = resolveAdapter(integration);
-  const { context, missing } = buildContext(integration, env);
+  const { context, missing } = await buildContextWithSecrets(dir, integration, env);
   try {
     const connection = await withTimeout(adapter.verifyConnection(context), context.timeoutMs);
     return { id, status: statusOf(connection), connection, missingCredentials: missing, message: connection.message };
@@ -17943,14 +18076,14 @@ async function listExternalWorkItems(dir, id, opts = {}, env = process.env) {
   const { integration } = requireIntegration(dir, id);
   const adapter = resolveAdapter(integration);
   if (!adapter.capabilities.workItems.list) throw integrationError("UNSUPPORTED_CAPABILITY", `Adapter "${adapter.id}" cannot list work items.`);
-  const { context } = buildContext(integration, env);
+  const { context } = await buildContextWithSecrets(dir, integration, env);
   return withTimeout(adapter.listWorkItems({ context, cursor: opts.cursor, pageSize: opts.pageSize, filters: opts.filters }), context.timeoutMs);
 }
 async function getExternalWorkItem(dir, id, externalId, env = process.env) {
   const { integration } = requireIntegration(dir, id);
   const adapter = resolveAdapter(integration);
   if (!adapter.capabilities.workItems.read) throw integrationError("UNSUPPORTED_CAPABILITY", `Adapter "${adapter.id}" cannot read work items.`);
-  const { context } = buildContext(integration, env);
+  const { context } = await buildContextWithSecrets(dir, integration, env);
   return withTimeout(adapter.getWorkItem({ context, externalId }), context.timeoutMs);
 }
 function findLinkedWorkItem(dir, integrationId, externalId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/cli",
-  "version": "3.82.0",
+  "version": "3.83.0",
   "description": "Knowledge Driven Development toolkit",
   "license": "MIT",
   "repository": {