@mycadet/credential-executor 0.0.1 → 0.12.6-dev.202610080043.b727a33

package/node_modules/@mycadet/credential-storage/src/static-credentials.ts

@@ -0,0 +1,396 @@
+/**
+ * Static credential metadata persistence primitives.
+ *
+ * Provides a portable, path-parameterized metadata store for local static
+ * credential records. This module has NO dependency on the assistant daemon,
+ * platform helpers, or any service-specific code — callers supply the file
+ * path and this module handles versioned JSON persistence with atomic writes.
+ *
+ * The assistant's `metadata-store.ts` wires in the platform-specific data
+ * directory and re-exports convenience functions that delegate here.
+ */
+
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+import type { InjectionTemplate, StaticCredentialRecord } from "./index.js";
+
+// ---------------------------------------------------------------------------
+// On-disk schema
+// ---------------------------------------------------------------------------
+
+/** Current on-disk schema version. */
+const CURRENT_VERSION = 5;
+
+interface MetadataFile {
+  version: typeof CURRENT_VERSION;
+  credentials: StaticCredentialRecord[];
+}
+
+/**
+ * Returned when the on-disk file has a version we don't understand.
+ * Callers that mutate state must check for this to avoid overwriting
+ * data written by a newer version of the app.
+ */
+interface UnknownVersionResult {
+  readonly unknownVersion: true;
+}
+
+type LoadResult = MetadataFile | UnknownVersionResult;
+
+function isUnknownVersion(r: LoadResult): r is UnknownVersionResult {
+  return "unknownVersion" in r;
+}
+
+// ---------------------------------------------------------------------------
+// Validation & migration helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if a value looks like a valid credential record (has required fields).
+ * Filters out corrupted or incomplete entries during migration.
+ */
+function isValidCredentialRecord(
+  record: unknown
+): record is Record<string, unknown> {
+  if (typeof record !== "object" || record == null) return false;
+  const r = record as Record<string, unknown>;
+  return (
+    typeof r.credentialId === "string" &&
+    typeof r.service === "string" &&
+    typeof r.field === "string" &&
+    typeof r.createdAt === "number" &&
+    typeof r.updatedAt === "number"
+  );
+}
+
+/**
+ * Migrate any record to v5 by stripping OAuth-specific fields that are
+ * now exclusively managed by the SQLite oauth-store.
+ */
+function migrateRecordToV5(
+  record: Record<string, unknown>
+): StaticCredentialRecord {
+  return {
+    credentialId: record.credentialId as string,
+    service: record.service as string,
+    field: record.field as string,
+    allowedTools: Array.isArray(record.allowedTools)
+      ? (record.allowedTools as string[])
+      : [],
+    allowedDomains: Array.isArray(record.allowedDomains)
+      ? (record.allowedDomains as string[])
+      : [],
+    usageDescription:
+      typeof record.usageDescription === "string"
+        ? record.usageDescription
+        : undefined,
+    alias: typeof record.alias === "string" ? record.alias : undefined,
+    injectionTemplates: Array.isArray(record.injectionTemplates)
+      ? (record.injectionTemplates as InjectionTemplate[])
+      : undefined,
+    createdAt: record.createdAt as number,
+    updatedAt: record.updatedAt as number,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Filesystem helpers (inlined to avoid assistant-specific imports)
+// ---------------------------------------------------------------------------
+
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function readTextFileSync(path: string): string | null {
+  try {
+    if (!existsSync(path)) return null;
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Core store implementation
+// ---------------------------------------------------------------------------
+
+function loadFile(
+  metadataPath: string,
+  saveFileFn: (data: MetadataFile, path: string) => void
+): LoadResult {
+  const raw = readTextFileSync(metadataPath);
+  if (raw == null) {
+    return { version: CURRENT_VERSION, credentials: [] };
+  }
+  try {
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data == null) {
+      return { version: CURRENT_VERSION, credentials: [] };
+    }
+    const fileVersion = typeof data.version === "number" ? data.version : 1;
+    if (
+      fileVersion !== 1 &&
+      fileVersion !== 2 &&
+      fileVersion !== 3 &&
+      fileVersion !== 4 &&
+      fileVersion !== 5
+    ) {
+      // Unrecognized version (future, fractional, negative, zero) — refuse to touch it
+      return { unknownVersion: true };
+    }
+    const rawCredentials: unknown[] = Array.isArray(data.credentials)
+      ? data.credentials
+      : [];
+    // Filter out malformed entries that lack required fields
+    const validRecords = rawCredentials.filter(isValidCredentialRecord);
+
+    if (fileVersion < CURRENT_VERSION) {
+      // Migrate all older versions to v5 by stripping OAuth-specific fields
+      // and removing ghost refresh_token records
+      const filtered = validRecords.filter(
+        (r) => (r as Record<string, unknown>).field !== "refresh_token"
+      );
+      const credentials = filtered.map(migrateRecordToV5);
+      const migrated: MetadataFile = { version: CURRENT_VERSION, credentials };
+      try {
+        saveFileFn(migrated, metadataPath);
+      } catch {
+        /* persist failed — will retry on next write */
+      }
+      return migrated;
+    }
+
+    return {
+      version: CURRENT_VERSION,
+      credentials: (validRecords as unknown) as StaticCredentialRecord[],
+    };
+  } catch {
+    // Corrupted / unparseable file — treat as empty to avoid data loss on next write
+    return { version: CURRENT_VERSION, credentials: [] };
+  }
+}
+
+function saveFile(data: MetadataFile, path: string): void {
+  const dir = dirname(path);
+  ensureDir(dir);
+  const tmpPath = join(dir, `.tmp-${randomUUID()}`);
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmpPath, path);
+}
+
+// ---------------------------------------------------------------------------
+// Policy input for upsert
+// ---------------------------------------------------------------------------
+
+/** Policy fields that can be set or updated when upserting a credential. */
+export interface StaticCredentialPolicyInput {
+  allowedTools?: string[];
+  allowedDomains?: string[];
+  usageDescription?: string;
+  /** Pass `null` to explicitly clear a previously-set alias. */
+  alias?: string | null;
+  /** Pass `null` to explicitly clear injection templates. */
+  injectionTemplates?: InjectionTemplate[] | null;
+}
+
+// ---------------------------------------------------------------------------
+// StaticCredentialMetadataStore
+// ---------------------------------------------------------------------------
+
+/**
+ * Portable, path-parameterized metadata store for local static credentials.
+ *
+ * Callers supply the file path; this class handles versioned JSON persistence,
+ * schema migration, and CRUD operations. It has no dependency on the assistant
+ * daemon or platform-specific code.
+ */
+export class StaticCredentialMetadataStore {
+  private metadataPath: string;
+  /** When set, reads and writes stay in process and do not touch the file. */
+  private memory: MetadataFile | null = null;
+
+  constructor(metadataPath: string) {
+    this.metadataPath = metadataPath;
+  }
+
+  /** Update the metadata file path (primarily for testing). */
+  setPath(path: string): void {
+    this.metadataPath = path;
+    this.memory = null;
+  }
+
+  /**
+   * Switch to an in-memory backing filled with `records`.
+   */
+  useMemory(records: StaticCredentialRecord[] = []): void {
+    this.memory = {
+      version: CURRENT_VERSION,
+      credentials: records.map((record) => ({ ...record })),
+    };
+  }
+
+  /** Get the current metadata file path. */
+  getPath(): string {
+    return this.metadataPath;
+  }
+
+  private load(): LoadResult {
+    if (this.memory) {
+      return this.memory;
+    }
+    return loadFile(this.metadataPath, saveFile);
+  }
+
+  private persist(data: MetadataFile): void {
+    if (this.memory) {
+      this.memory = data;
+      return;
+    }
+    saveFile(data, this.metadataPath);
+  }
+
+  /**
+   * Throws if the metadata file has an unrecognized version.
+   * Call this before performing irreversible credential store operations
+   * so the operation fails cleanly before any side effects.
+   */
+  assertWritable(): void {
+    const result = this.load();
+    if (isUnknownVersion(result)) {
+      throw new Error(
+        "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
+      );
+    }
+  }
+
+  /**
+   * Create or update a credential metadata record.
+   * If a record with the same service+field exists, it is updated.
+   */
+  upsert(
+    service: string,
+    field: string,
+    policy?: StaticCredentialPolicyInput
+  ): StaticCredentialRecord {
+    const result = this.load();
+    if (isUnknownVersion(result)) {
+      throw new Error(
+        "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
+      );
+    }
+    const data = result;
+    const now = Date.now();
+
+    const existing = data.credentials.find(
+      (c) => c.service === service && c.field === field
+    );
+
+    if (existing) {
+      if (policy?.allowedTools !== undefined) {
+        existing.allowedTools = policy.allowedTools;
+      }
+      if (policy?.allowedDomains !== undefined) {
+        existing.allowedDomains = policy.allowedDomains;
+      }
+      if (policy?.usageDescription !== undefined) {
+        existing.usageDescription = policy.usageDescription;
+      }
+      if (policy?.alias !== undefined) {
+        if (policy.alias == null) {
+          delete existing.alias;
+        } else {
+          existing.alias = policy.alias;
+        }
+      }
+      if (policy?.injectionTemplates !== undefined) {
+        if (policy.injectionTemplates == null) {
+          delete existing.injectionTemplates;
+        } else {
+          existing.injectionTemplates = policy.injectionTemplates;
+        }
+      }
+      existing.updatedAt = now;
+      this.persist(data);
+      return existing;
+    }
+
+    const record: StaticCredentialRecord = {
+      credentialId: randomUUID(),
+      service,
+      field,
+      allowedTools: policy?.allowedTools ?? [],
+      allowedDomains: policy?.allowedDomains ?? [],
+      usageDescription: policy?.usageDescription,
+      alias: policy?.alias ?? undefined,
+      injectionTemplates: policy?.injectionTemplates ?? undefined,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    data.credentials.push(record);
+    this.persist(data);
+    return record;
+  }
+
+  /**
+   * Get metadata for a credential by service and field.
+   */
+  getByServiceField(
+    service: string,
+    field: string
+  ): StaticCredentialRecord | undefined {
+    const result = this.load();
+    if (isUnknownVersion(result)) return undefined;
+    return result.credentials.find(
+      (c) => c.service === service && c.field === field
+    );
+  }
+
+  /**
+   * Get metadata for a credential by its opaque ID.
+   */
+  getById(credentialId: string): StaticCredentialRecord | undefined {
+    const result = this.load();
+    if (isUnknownVersion(result)) return undefined;
+    return result.credentials.find((c) => c.credentialId === credentialId);
+  }
+
+  /**
+   * List all credential metadata records.
+   */
+  list(): StaticCredentialRecord[] {
+    const result = this.load();
+    if (isUnknownVersion(result)) return [];
+    return result.credentials;
+  }
+
+  /**
+   * Delete metadata for a credential.
+   */
+  delete(service: string, field: string): boolean {
+    const result = this.load();
+    if (isUnknownVersion(result)) {
+      throw new Error(
+        "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
+      );
+    }
+    const data = result;
+    const idx = data.credentials.findIndex(
+      (c) => c.service === service && c.field === field
+    );
+    if (idx === -1) return false;
+    data.credentials.splice(idx, 1);
+    this.persist(data);
+    return true;
+  }
+}

package/node_modules/@mycadet/credential-storage/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/node_modules/@mycadet/egress-proxy/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@mycadet/egress-proxy",
+  "version": "0.0.1",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test src/"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.10",
+    "typescript": "5.9.3"
+  }
+}

package/node_modules/@mycadet/egress-proxy/src/__tests__/package-boundary.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Package boundary tests for @mycadet/egress-proxy.
+ *
+ * These tests ensure the egress-proxy package remains isolated from
+ * assistant runtime and CES server implementation modules. If a direct
+ * import of those modules is introduced, these tests will fail.
+ *
+ * Tightened boundaries (added):
+ * - Does NOT import from x-client packages (@mycadet/assistant-client,
+ *   @mycadet/ces-client, @mycadet/gateway-client).
+ * - Does NOT import from @mycadet/service-contracts (the egress-proxy
+ *   package deals only with proxy session lifecycle and must not depend on
+ *   CES wire-protocol types).
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const PKG_SRC = resolve(import.meta.dir, "..");
+
+/** Recursively collect all .ts source files (excluding tests and declaration files). */
+async function collectSourceFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "__tests__" || entry.name === "node_modules") continue;
+      files.push(...(await collectSourceFiles(fullPath)));
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith(".ts") &&
+      !entry.name.endsWith(".d.ts") &&
+      !entry.name.endsWith(".test.ts")
+    ) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+/** Read file content as UTF-8. */
+async function readSource(filePath: string): Promise<string> {
+  return Bun.file(filePath).text();
+}
+
+/**
+ * Forbidden import patterns — if any source file in packages/egress-proxy
+ * imports from these paths, the package boundary has been violated.
+ */
+const FORBIDDEN_PATTERNS = [
+  // Assistant runtime internals
+  /from\s+['"].*\/assistant\/src\//,
+  /from\s+['"]@mycadet\/assistant/,
+  /import\s*\(.*\/assistant\/src\//,
+  /require\s*\(.*\/assistant\/src\//,
+  /import\s+['"].*\/assistant\/src\//,
+  /import\s+['"]@mycadet\/assistant/,
+
+  // CES server modules (future — reserve the boundary now)
+  /from\s+['"].*\/ces\/src\//,
+  /from\s+['"]@mycadet\/ces/,
+  /import\s*\(.*\/ces\/src\//,
+  /require\s*\(.*\/ces\/src\//,
+  /import\s+['"].*\/ces\/src\//,
+  /import\s+['"]@mycadet\/ces/,
+
+  // Gateway internals
+  /from\s+['"].*\/gateway\/src\//,
+  /from\s+['"]@mycadet\/cadet-gateway/,
+  /import\s*\(.*\/gateway\/src\//,
+  /require\s*\(.*\/gateway\/src\//,
+  /import\s+['"].*\/gateway\/src\//,
+  /import\s+['"]@mycadet\/cadet-gateway/,
+
+  // x-client packages (must not depend on any typed service client)
+  /from\s+['"]@mycadet\/assistant-client(?:\/|['"])/,
+  /import\s+['"]@mycadet\/assistant-client(?:\/|['"])/,
+  /require\s*\(['"]@mycadet\/assistant-client(?:\/|['"])/,
+  /from\s+['"]@mycadet\/ces-client(?:\/|['"])/,
+  /import\s+['"]@mycadet\/ces-client(?:\/|['"])/,
+  /require\s*\(['"]@mycadet\/ces-client(?:\/|['"])/,
+  /from\s+['"]@mycadet\/gateway-client(?:\/|['"])/,
+  /import\s+['"]@mycadet\/gateway-client(?:\/|['"])/,
+  /require\s*\(['"]@mycadet\/gateway-client(?:\/|['"])/,
+
+  // service-contracts (RPC protocol types — egress-proxy must not depend on CES wire types)
+  /from\s+['"]@mycadet\/service-contracts(?:\/|['"])/,
+  /import\s+['"]@mycadet\/service-contracts(?:\/|['"])/,
+  /require\s*\(['"]@mycadet\/service-contracts(?:\/|['"])/,
+  /from\s+['"]@mycadet\/ces-contracts(?:\/|['"])/,
+  /import\s+['"]@mycadet\/ces-contracts(?:\/|['"])/,
+  /require\s*\(['"]@mycadet\/ces-contracts(?:\/|['"])/,
+];
+
+describe("package boundary", () => {
+  test("source files do not import assistant, CES, or gateway modules", async () => {
+    const sourceFiles = await collectSourceFiles(PKG_SRC);
+    expect(sourceFiles.length).toBeGreaterThan(0);
+
+    const violations: string[] = [];
+
+    for (const filePath of sourceFiles) {
+      const content = await readSource(filePath);
+      for (const pattern of FORBIDDEN_PATTERNS) {
+        const match = content.match(pattern);
+        if (match) {
+          const relativePath = filePath.replace(PKG_SRC + "/", "");
+          violations.push(`${relativePath}: ${match[0]}`);
+        }
+      }
+    }
+
+    if (violations.length > 0) {
+      throw new Error(
+        `Package boundary violated — egress-proxy must not import assistant, CES, or gateway modules:\n` +
+          violations.map((v) => `  - ${v}`).join("\n"),
+      );
+    }
+  });
+
+  test("package.json has no dependencies on assistant, CES, gateway, x-client, or service-contracts", async () => {
+    const pkgJsonPath = resolve(PKG_SRC, "..", "package.json");
+    const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
+
+    const allDeps = {
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies,
+      ...pkgJson.peerDependencies,
+      ...pkgJson.optionalDependencies,
+    };
+
+    const forbidden = [
+      "@mycadet/assistant",
+      "@mycadet/ces",
+      "@mycadet/gateway",
+      "@mycadet/assistant-client",
+      "@mycadet/ces-client",
+      "@mycadet/ces-contracts",
+      "@mycadet/gateway-client",
+      "@mycadet/service-contracts",
+    ];
+
+    for (const dep of forbidden) {
+      expect(allDeps).not.toHaveProperty(dep);
+    }
+  });
+
+  test("exports the expected egress control primitives", async () => {
+    const mod = await import("../index.js");
+
+    // The module should export only types at this stage.
+    // TypeScript types are erased at runtime, so we verify the module
+    // loads without error and doesn't unexpectedly export runtime values
+    // that would indicate coupling to implementation modules.
+    //
+    // The key assertion is that the module exists and is importable
+    // without pulling in assistant/CES/gateway runtime code.
+    expect(mod).toBeDefined();
+  });
+});

package/node_modules/@mycadet/egress-proxy/src/index.ts

@@ -0,0 +1,54 @@
+/**
+ * @mycadet/egress-proxy — Reusable outbound proxy and request-policy core.
+ *
+ * This package defines the portable primitives shared by the legacy
+ * trusted-session shell proxy flows (assistant/src/outbound-proxy) and the
+ * CES secure command egress enforcement layer. It intentionally has zero
+ * dependencies on assistant runtime or CES server modules.
+ */
+
+// ---------------------------------------------------------------------------
+// Types — session, policy, credential injection, env vars
+// ---------------------------------------------------------------------------
+
+export type {
+  AllowedTarget,
+  CredentialInjectionTemplate,
+  CredentialInjectionType,
+  PolicyCallback,
+  PolicyDecision,
+  PolicyDecisionAmbiguous,
+  PolicyDecisionAskMissingCredential,
+  PolicyDecisionAskUnauthenticated,
+  PolicyDecisionMatched,
+  PolicyDecisionMissing,
+  PolicyDecisionUnauthenticated,
+  ProxyApprovalCallback,
+  ProxyApprovalRequest,
+  ProxyEnvVars,
+  ProxySession,
+  ProxySessionConfig,
+  ProxySessionId,
+  ProxySessionStatus,
+  RequestTargetContext,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Session core — lifecycle, store, env injection, atomic acquire
+// ---------------------------------------------------------------------------
+
+export type { ManagedSession, SessionStartHooks } from "./session-core.js";
+
+export {
+  SessionStore,
+  cloneSession,
+  createSession,
+  credentialIdsMatch,
+  getActiveSession,
+  getOrStartSession,
+  getSessionEnv,
+  getSessionsForConversation,
+  startSession,
+  stopAllSessions,
+  stopSession,
+} from "./session-core.js";