@agenshield/ipc 0.1.0

package/index.js

@@ -0,0 +1,1377 @@
+// libs/shield-ipc/src/types/backup.ts
+var BACKUP_CONFIG = {
+  /** Directory for AgenShield configuration */
+  configDir: "/etc/agenshield",
+  /** Backup file path */
+  backupPath: "/etc/agenshield/backup.json",
+  /** Directory permissions (readable by all, writable by root) */
+  dirMode: 493,
+  /** File permissions (root only) */
+  fileMode: 384
+};
+
+// libs/shield-ipc/src/types/policy.ts
+var DEFAULT_CHANNEL_RESTRICTIONS = [
+  { operation: "http_request", allowedChannels: ["socket", "http"] },
+  { operation: "file_read", allowedChannels: ["socket", "http"] },
+  { operation: "file_write", allowedChannels: ["socket"] },
+  { operation: "file_list", allowedChannels: ["socket", "http"] },
+  { operation: "exec", allowedChannels: ["socket"] },
+  { operation: "open_url", allowedChannels: ["socket", "http"] },
+  { operation: "secret_inject", allowedChannels: ["socket"] },
+  { operation: "ping", allowedChannels: ["socket", "http"] },
+  { operation: "policy_check", allowedChannels: ["socket", "http"] }
+];
+
+// libs/shield-ipc/src/types/auth.ts
+var DEFAULT_AUTH_CONFIG = {
+  sessionTtlMs: 30 * 60 * 1e3,
+  // 30 minutes
+  maxFailedAttempts: 5,
+  lockoutDurationMs: 15 * 60 * 1e3
+  // 15 minutes
+};
+
+// libs/shield-ipc/src/schemas/config.schema.ts
+import { z } from "zod";
+var UserDefinitionSchema = z.object({
+  username: z.string().min(1).max(32).regex(/^[a-z_][a-z0-9_-]*$/),
+  uid: z.number().int().min(500).max(65534),
+  gid: z.number().int().min(500).max(65534),
+  shell: z.string().min(1),
+  home: z.string().min(1),
+  realname: z.string().min(1).max(100),
+  groups: z.array(z.string().regex(/^[a-z_][a-z0-9_-]*$/))
+});
+var GroupDefinitionSchema = z.object({
+  name: z.string().min(1).max(32).regex(/^[a-z_][a-z0-9_-]*$/),
+  gid: z.number().int().min(500).max(65534),
+  description: z.string().min(1).max(100)
+});
+var UserConfigSchema = z.object({
+  agentUser: UserDefinitionSchema,
+  brokerUser: UserDefinitionSchema,
+  groups: z.object({
+    socket: GroupDefinitionSchema,
+    workspace: GroupDefinitionSchema
+  }),
+  prefix: z.string().max(20).default(""),
+  baseName: z.string().min(1).max(20).regex(/^[a-z][a-z0-9_]*$/).default("agenshield"),
+  baseUid: z.number().int().min(500).max(65e3).default(5200),
+  baseGid: z.number().int().min(500).max(65e3).default(5100)
+});
+var PathsConfigSchema = z.object({
+  socketPath: z.string().default("/var/run/agenshield/agenshield.sock"),
+  configDir: z.string().default("/opt/agenshield/config"),
+  policiesDir: z.string().default("/opt/agenshield/policies"),
+  seatbeltDir: z.string().default("/etc/agenshield/seatbelt"),
+  logDir: z.string().default("/var/log/agenshield"),
+  agentHomeDir: z.string().default("/Users/agenshield_agent"),
+  socketDir: z.string().default("/var/run/agenshield")
+});
+var InstallationConfigSchema = z.object({
+  users: UserConfigSchema,
+  paths: PathsConfigSchema,
+  httpFallback: z.boolean().default(true),
+  httpPort: z.number().int().min(1024).max(65535).default(5201)
+  // Broker HTTP fallback port
+});
+var DaemonConfigSchema = z.object({
+  port: z.number().min(1).max(65535).default(5200),
+  host: z.string().default("localhost"),
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  enableHostsEntry: z.boolean().default(false)
+});
+var PolicyConfigSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(100),
+  action: z.enum(["allow", "deny", "approval"]),
+  target: z.enum(["skill", "command", "url", "filesystem"]),
+  patterns: z.array(z.string()),
+  enabled: z.boolean().default(true),
+  operations: z.array(z.string()).optional()
+});
+var VaultConfigSchema = z.object({
+  enabled: z.boolean(),
+  provider: z.enum(["local", "env"])
+});
+var ShieldConfigSchema = z.object({
+  version: z.string(),
+  daemon: DaemonConfigSchema,
+  policies: z.array(PolicyConfigSchema).default([]),
+  vault: VaultConfigSchema.optional()
+});
+
+// libs/shield-ipc/src/schemas/ops.schema.ts
+import { z as z2 } from "zod";
+var OperationTypeSchema = z2.enum([
+  "http_request",
+  "file_read",
+  "file_write",
+  "file_list",
+  "exec",
+  "open_url",
+  "secret_inject",
+  "ping",
+  "policy_check"
+]);
+var HttpRequestParamsSchema = z2.object({
+  url: z2.string().url(),
+  method: z2.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional(),
+  headers: z2.record(z2.string(), z2.string()).optional(),
+  body: z2.string().optional(),
+  timeout: z2.number().positive().optional(),
+  followRedirects: z2.boolean().optional()
+});
+var FileReadParamsSchema = z2.object({
+  path: z2.string().min(1),
+  encoding: z2.string().optional()
+});
+var FileWriteParamsSchema = z2.object({
+  path: z2.string().min(1),
+  content: z2.string(),
+  encoding: z2.string().optional(),
+  mode: z2.number().optional()
+});
+var FileListParamsSchema = z2.object({
+  path: z2.string().min(1),
+  recursive: z2.boolean().optional(),
+  pattern: z2.string().optional()
+});
+var ExecParamsSchema = z2.object({
+  command: z2.string().min(1),
+  args: z2.array(z2.string()).optional(),
+  cwd: z2.string().optional(),
+  env: z2.record(z2.string(), z2.string()).optional(),
+  timeout: z2.number().positive().optional(),
+  shell: z2.boolean().optional()
+});
+var OpenUrlParamsSchema = z2.object({
+  url: z2.string().url(),
+  browser: z2.string().optional()
+});
+var SecretInjectParamsSchema = z2.object({
+  name: z2.string().min(1),
+  targetEnv: z2.string().optional()
+});
+var PingParamsSchema = z2.object({
+  echo: z2.string().optional()
+});
+var PolicyCheckParamsSchema = z2.object({
+  operation: OperationTypeSchema,
+  target: z2.string().min(1)
+});
+var BrokerRequestSchema = z2.object({
+  jsonrpc: z2.literal("2.0"),
+  id: z2.union([z2.string(), z2.number()]),
+  method: OperationTypeSchema,
+  params: z2.record(z2.string(), z2.unknown()),
+  channel: z2.enum(["socket", "http"]).optional()
+});
+var BrokerErrorSchema = z2.object({
+  code: z2.number(),
+  message: z2.string(),
+  data: z2.unknown().optional()
+});
+var BrokerResponseSchema = z2.object({
+  jsonrpc: z2.literal("2.0"),
+  id: z2.union([z2.string(), z2.number()]),
+  result: z2.unknown().optional(),
+  error: BrokerErrorSchema.optional()
+});
+
+// libs/shield-ipc/src/schemas/policy.schema.ts
+import { z as z3 } from "zod";
+var PolicyRuleSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().min(1),
+  action: z3.enum(["allow", "deny", "approval"]),
+  target: z3.enum(["skill", "command", "url", "filesystem"]),
+  operations: z3.array(OperationTypeSchema),
+  patterns: z3.array(z3.string()),
+  enabled: z3.boolean(),
+  priority: z3.number().optional()
+});
+var FsConstraintsSchema = z3.object({
+  allowedPaths: z3.array(z3.string()),
+  deniedPatterns: z3.array(z3.string())
+});
+var NetworkConstraintsSchema = z3.object({
+  allowedHosts: z3.array(z3.string()),
+  deniedHosts: z3.array(z3.string()),
+  allowedPorts: z3.array(z3.number().int().positive())
+});
+var EnvInjectionRuleSchema = z3.object({
+  secretName: z3.string().min(1),
+  targetEnv: z3.string().min(1),
+  operations: z3.array(OperationTypeSchema)
+});
+var PolicyConfigurationSchema = z3.object({
+  version: z3.string(),
+  rules: z3.array(PolicyRuleSchema),
+  defaultAction: z3.enum(["allow", "deny"]),
+  fsConstraints: FsConstraintsSchema.optional(),
+  networkConstraints: NetworkConstraintsSchema.optional(),
+  envInjection: z3.array(EnvInjectionRuleSchema).optional()
+});
+var PolicyEvaluationResultSchema = z3.object({
+  allowed: z3.boolean(),
+  policyId: z3.string().optional(),
+  reason: z3.string().optional(),
+  durationMs: z3.number().optional()
+});
+var ChannelRestrictionSchema = z3.object({
+  operation: OperationTypeSchema,
+  allowedChannels: z3.array(z3.enum(["socket", "http"]))
+});
+
+// libs/shield-ipc/src/schemas/agenco.schema.ts
+import { z as z4 } from "zod";
+var AgenCoAuthStartRequestSchema = z4.object({
+  scopes: z4.array(z4.string()).optional()
+});
+var AgenCoAuthStartResponseSchema = z4.object({
+  authUrl: z4.string().url(),
+  state: z4.string().min(1),
+  callbackPort: z4.number().int().min(1024).max(65535)
+});
+var AgenCoAuthCallbackRequestSchema = z4.object({
+  code: z4.string().min(1),
+  state: z4.string().min(1)
+});
+var AgenCoAuthCallbackResponseSchema = z4.object({
+  success: z4.boolean(),
+  error: z4.string().optional()
+});
+var AgenCoAuthStatusResponseSchema = z4.object({
+  authenticated: z4.boolean(),
+  expired: z4.boolean(),
+  expiresAt: z4.string().nullable(),
+  connectedIntegrations: z4.array(z4.string())
+});
+var AgenCoToolRunRequestSchema = z4.object({
+  integration: z4.string().min(1),
+  tool: z4.string().min(1),
+  params: z4.record(z4.string(), z4.unknown()).optional()
+});
+var AgenCoToolRunResponseSchema = z4.object({
+  success: z4.boolean(),
+  result: z4.unknown().optional(),
+  error: z4.string().optional()
+});
+var AgenCoToolListRequestSchema = z4.object({
+  integration: z4.string().optional(),
+  connectedOnly: z4.boolean().optional()
+});
+var AgenCoToolSchema = z4.object({
+  integration: z4.string(),
+  tool: z4.string(),
+  description: z4.string(),
+  connected: z4.boolean().optional(),
+  connectUrl: z4.string().optional()
+});
+var AgenCoToolListResponseSchema = z4.object({
+  tools: z4.array(AgenCoToolSchema)
+});
+var AgenCoToolSearchRequestSchema = z4.object({
+  query: z4.string().min(1),
+  integration: z4.string().optional()
+});
+var AgenCoIntegrationsListRequestSchema = z4.object({
+  category: z4.string().optional(),
+  search: z4.string().optional()
+});
+var AgenCoIntegrationActionSchema = z4.object({
+  name: z4.string(),
+  description: z4.string()
+});
+var AgenCoIntegrationSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  description: z4.string(),
+  category: z4.string(),
+  toolsCount: z4.number().int().nonnegative(),
+  actions: z4.array(AgenCoIntegrationActionSchema).optional()
+});
+var AgenCoIntegrationsListResponseSchema = z4.object({
+  integrations: z4.array(AgenCoIntegrationSchema),
+  totalCount: z4.number().int().nonnegative()
+});
+var AgenCoConnectedIntegrationSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  connectedAt: z4.string(),
+  status: z4.string(),
+  account: z4.string().optional(),
+  requiresReauth: z4.boolean().optional()
+});
+var AgenCoConnectedIntegrationsResponseSchema = z4.object({
+  integrations: z4.array(AgenCoConnectedIntegrationSchema)
+});
+var AgenCoConnectIntegrationRequestSchema = z4.object({
+  integration: z4.string().min(1),
+  scopes: z4.array(z4.string()).optional()
+});
+var AgenCoConnectIntegrationResponseSchema = z4.object({
+  status: z4.enum(["auth_required", "already_connected", "connected"]),
+  oauthUrl: z4.string().url().optional(),
+  expiresIn: z4.number().optional(),
+  instructions: z4.string().optional(),
+  account: z4.string().optional(),
+  connectedAt: z4.string().optional()
+});
+
+// libs/shield-ipc/src/schemas/state.schema.ts
+import { z as z5 } from "zod";
+var DaemonStateSchema = z5.object({
+  running: z5.boolean(),
+  pid: z5.number().int().positive().optional(),
+  startedAt: z5.string().optional(),
+  port: z5.number().int().min(1024).max(65535)
+});
+var UserStateSchema = z5.object({
+  username: z5.string().min(1).max(32).regex(/^[a-z_][a-z0-9_-]*$/),
+  uid: z5.number().int().min(500).max(65534),
+  type: z5.enum(["agent", "broker"]),
+  createdAt: z5.string(),
+  homeDir: z5.string().min(1)
+});
+var GroupStateSchema = z5.object({
+  name: z5.string().min(1).max(32).regex(/^[a-z_][a-z0-9_-]*$/),
+  gid: z5.number().int().min(500).max(65534),
+  type: z5.enum(["socket", "workspace"])
+});
+var AgenCoStateSchema = z5.object({
+  authenticated: z5.boolean(),
+  lastAuthAt: z5.string().optional(),
+  connectedIntegrations: z5.array(z5.string())
+});
+var InstallationStateSchema = z5.object({
+  preset: z5.string().min(1),
+  baseName: z5.string().min(1),
+  prefix: z5.string().optional(),
+  wrappers: z5.array(z5.string()),
+  seatbeltInstalled: z5.boolean()
+});
+var PasscodeProtectionStateSchema = z5.object({
+  enabled: z5.boolean(),
+  allowAnonymousReadOnly: z5.boolean().optional(),
+  failedAttempts: z5.number().int().nonnegative().optional(),
+  lockedUntil: z5.string().optional()
+});
+var SystemStateSchema = z5.object({
+  version: z5.string().min(1),
+  installedAt: z5.string(),
+  daemon: DaemonStateSchema,
+  users: z5.array(UserStateSchema),
+  groups: z5.array(GroupStateSchema),
+  agenco: AgenCoStateSchema,
+  installation: InstallationStateSchema,
+  passcodeProtection: PasscodeProtectionStateSchema.optional()
+});
+
+// libs/shield-ipc/src/schemas/vault.schema.ts
+import { z as z7 } from "zod";
+
+// libs/shield-ipc/src/schemas/auth.schema.ts
+import { z as z6 } from "zod";
+var passcodeSchema = z6.string().min(4, "Passcode must be at least 4 characters");
+var AuthStatusResponseSchema = z6.object({
+  passcodeSet: z6.boolean(),
+  protectionEnabled: z6.boolean(),
+  allowAnonymousReadOnly: z6.boolean(),
+  lockedOut: z6.boolean(),
+  lockedUntil: z6.string().optional()
+});
+var UnlockRequestSchema = z6.object({
+  passcode: passcodeSchema
+});
+var UnlockResponseSchema = z6.object({
+  success: z6.boolean(),
+  token: z6.string().optional(),
+  expiresAt: z6.number().int().positive().optional(),
+  error: z6.string().optional(),
+  remainingAttempts: z6.number().int().nonnegative().optional()
+});
+var LockRequestSchema = z6.object({
+  token: z6.string().min(1)
+});
+var LockResponseSchema = z6.object({
+  success: z6.boolean()
+});
+var SetupPasscodeRequestSchema = z6.object({
+  passcode: passcodeSchema,
+  enableProtection: z6.boolean().optional()
+});
+var SetupPasscodeResponseSchema = z6.object({
+  success: z6.boolean(),
+  error: z6.string().optional()
+});
+var ChangePasscodeRequestSchema = z6.object({
+  oldPasscode: passcodeSchema.optional(),
+  newPasscode: passcodeSchema
+});
+var ChangePasscodeResponseSchema = z6.object({
+  success: z6.boolean(),
+  error: z6.string().optional()
+});
+var SessionSchema = z6.object({
+  token: z6.string().min(1),
+  createdAt: z6.number().int().positive(),
+  expiresAt: z6.number().int().positive(),
+  clientId: z6.string().optional()
+});
+var AuthConfigSchema = z6.object({
+  sessionTtlMs: z6.number().int().positive(),
+  maxFailedAttempts: z6.number().int().positive(),
+  lockoutDurationMs: z6.number().int().positive()
+});
+var PasscodeDataSchema = z6.object({
+  hash: z6.string().min(1),
+  setAt: z6.string(),
+  changedAt: z6.string().optional()
+});
+
+// libs/shield-ipc/src/schemas/vault.schema.ts
+var AgenCoSecretsSchema = z7.object({
+  accessToken: z7.string().min(1),
+  refreshToken: z7.string().min(1),
+  expiresAt: z7.number().int().positive(),
+  clientId: z7.string().min(1),
+  clientSecret: z7.string().min(1)
+});
+var VaultContentsSchema = z7.object({
+  agenco: AgenCoSecretsSchema.optional(),
+  envSecrets: z7.record(z7.string(), z7.string()),
+  sensitivePatterns: z7.array(z7.string()),
+  passcode: PasscodeDataSchema.optional()
+});
+
+// libs/shield-ipc/src/catalog.ts
+var COMMAND_CATALOG = {
+  // ── Network ────────────────────────────────────────────────
+  curl: {
+    description: "Transfer data using network protocols",
+    category: "network",
+    risk: "high",
+    riskReason: "Can exfiltrate data or download malicious payloads",
+    tags: ["http", "download", "upload", "api", "request"]
+  },
+  wget: {
+    description: "Download files from the web",
+    category: "network",
+    risk: "high",
+    riskReason: "Can download malicious payloads or exfiltrate via HTTP",
+    tags: ["http", "download", "fetch", "web"]
+  },
+  ssh: {
+    description: "Secure shell remote login",
+    category: "network",
+    risk: "high",
+    riskReason: "Opens remote shell sessions and can tunnel traffic",
+    tags: ["remote", "login", "tunnel", "secure"]
+  },
+  scp: {
+    description: "Secure copy files over SSH",
+    category: "network",
+    risk: "high",
+    riskReason: "Can exfiltrate files to remote hosts",
+    tags: ["copy", "remote", "transfer", "secure"]
+  },
+  rsync: {
+    description: "Fast incremental file transfer",
+    category: "network",
+    risk: "high",
+    riskReason: "Can sync large amounts of data to remote hosts",
+    tags: ["sync", "copy", "remote", "transfer", "backup"]
+  },
+  nc: {
+    description: "Netcat \u2014 arbitrary TCP/UDP connections",
+    category: "network",
+    risk: "high",
+    riskReason: "Can open arbitrary network connections and reverse shells",
+    tags: ["netcat", "tcp", "udp", "socket", "listen"]
+  },
+  telnet: {
+    description: "Unencrypted remote terminal protocol",
+    category: "network",
+    risk: "high",
+    riskReason: "Unencrypted remote access, can connect to arbitrary ports",
+    tags: ["remote", "terminal", "unencrypted"]
+  },
+  ftp: {
+    description: "File transfer protocol client",
+    category: "network",
+    risk: "high",
+    riskReason: "Unencrypted file transfers, can exfiltrate data",
+    tags: ["transfer", "upload", "download", "unencrypted"]
+  },
+  sftp: {
+    description: "Secure file transfer over SSH",
+    category: "network",
+    risk: "high",
+    riskReason: "Can transfer files to/from remote hosts",
+    tags: ["transfer", "upload", "download", "secure", "ssh"]
+  },
+  nslookup: {
+    description: "Query DNS name servers",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only DNS lookups",
+    tags: ["dns", "lookup", "resolve", "nameserver"]
+  },
+  dig: {
+    description: "DNS lookup utility",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only DNS queries",
+    tags: ["dns", "lookup", "resolve", "query"]
+  },
+  host: {
+    description: "DNS lookup utility",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only DNS resolution",
+    tags: ["dns", "lookup", "resolve"]
+  },
+  ping: {
+    description: "Send ICMP echo requests",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only network reachability check",
+    tags: ["icmp", "reachability", "latency", "network"]
+  },
+  traceroute: {
+    description: "Trace packet route to host",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only route tracing",
+    tags: ["route", "hops", "network", "diagnostics"]
+  },
+  netstat: {
+    description: "Display network connections and stats",
+    category: "network",
+    risk: "low",
+    riskReason: "Read-only network status",
+    tags: ["connections", "ports", "sockets", "status"]
+  },
+  ifconfig: {
+    description: "Configure or display network interfaces",
+    category: "network",
+    risk: "medium",
+    riskReason: "Can modify network interface configuration",
+    tags: ["interface", "ip", "config", "adapter"]
+  },
+  ip: {
+    description: "Show/manipulate routing and network devices",
+    category: "network",
+    risk: "medium",
+    riskReason: "Can modify routing tables and network interfaces",
+    tags: ["routing", "interface", "address", "link"]
+  },
+  // ── Package Managers ───────────────────────────────────────
+  npm: {
+    description: "Node.js package manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary post-install scripts",
+    tags: ["node", "install", "packages", "javascript", "registry"]
+  },
+  npx: {
+    description: "Execute npm package binaries",
+    category: "package-manager",
+    risk: "high",
+    riskReason: "Downloads and executes arbitrary packages on the fly",
+    tags: ["node", "execute", "run", "packages", "javascript"]
+  },
+  yarn: {
+    description: "Fast Node.js package manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary post-install scripts",
+    tags: ["node", "install", "packages", "javascript", "registry"]
+  },
+  pnpm: {
+    description: "Efficient Node.js package manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary post-install scripts",
+    tags: ["node", "install", "packages", "javascript", "registry"]
+  },
+  pip: {
+    description: "Python package installer",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary setup scripts",
+    tags: ["python", "install", "packages", "pypi"]
+  },
+  pip3: {
+    description: "Python 3 package installer",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary setup scripts",
+    tags: ["python", "install", "packages", "pypi"]
+  },
+  brew: {
+    description: "macOS/Linux package manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install system-level software and modify PATH",
+    tags: ["homebrew", "install", "macos", "linux", "packages"]
+  },
+  gem: {
+    description: "Ruby package manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with native extensions",
+    tags: ["ruby", "install", "packages", "rubygems"]
+  },
+  cargo: {
+    description: "Rust package manager and build tool",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Compiles and runs arbitrary Rust code during install",
+    tags: ["rust", "install", "build", "crates", "compile"]
+  },
+  composer: {
+    description: "PHP dependency manager",
+    category: "package-manager",
+    risk: "medium",
+    riskReason: "Can install packages with arbitrary scripts",
+    tags: ["php", "install", "packages", "packagist"]
+  },
+  apt: {
+    description: "Debian/Ubuntu package manager",
+    category: "package-manager",
+    risk: "high",
+    riskReason: "System-level package installation requiring root",
+    tags: ["debian", "ubuntu", "install", "system", "linux"]
+  },
+  yum: {
+    description: "RPM-based package manager",
+    category: "package-manager",
+    risk: "high",
+    riskReason: "System-level package installation requiring root",
+    tags: ["redhat", "centos", "install", "system", "linux", "rpm"]
+  },
+  // ── Shells ─────────────────────────────────────────────────
+  bash: {
+    description: "Bourne-Again SHell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal", "bourne"]
+  },
+  zsh: {
+    description: "Z shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal"]
+  },
+  sh: {
+    description: "POSIX shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal", "posix"]
+  },
+  fish: {
+    description: "Friendly interactive shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal", "interactive"]
+  },
+  dash: {
+    description: "Debian Almquist shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal", "posix"]
+  },
+  ksh: {
+    description: "KornShell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal"]
+  },
+  csh: {
+    description: "C shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal"]
+  },
+  tcsh: {
+    description: "Enhanced C shell",
+    category: "shell",
+    risk: "high",
+    riskReason: "Full shell access \u2014 can execute arbitrary commands",
+    tags: ["shell", "script", "terminal"]
+  },
+  // ── System ─────────────────────────────────────────────────
+  ls: {
+    description: "List directory contents",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only directory listing",
+    tags: ["list", "directory", "files"]
+  },
+  cp: {
+    description: "Copy files and directories",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can overwrite files and duplicate sensitive data",
+    tags: ["copy", "duplicate", "file"]
+  },
+  mv: {
+    description: "Move or rename files",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can overwrite existing files",
+    tags: ["move", "rename", "file"]
+  },
+  rm: {
+    description: "Remove files or directories",
+    category: "system",
+    risk: "high",
+    riskReason: "Can permanently delete critical files",
+    tags: ["delete", "remove", "file"]
+  },
+  mkdir: {
+    description: "Create directories",
+    category: "system",
+    risk: "low",
+    riskReason: "Creates new directories only",
+    tags: ["create", "directory", "folder"]
+  },
+  chmod: {
+    description: "Change file permissions",
+    category: "system",
+    risk: "high",
+    riskReason: "Can make files executable or world-readable",
+    tags: ["permissions", "access", "mode", "security"]
+  },
+  chown: {
+    description: "Change file ownership",
+    category: "system",
+    risk: "high",
+    riskReason: "Can transfer file ownership, requires root",
+    tags: ["ownership", "user", "group", "security"]
+  },
+  chgrp: {
+    description: "Change group ownership",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can change file group access",
+    tags: ["ownership", "group", "security"]
+  },
+  cat: {
+    description: "Concatenate and display files",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file output",
+    tags: ["read", "display", "file", "output"]
+  },
+  echo: {
+    description: "Display text or write to files",
+    category: "system",
+    risk: "low",
+    riskReason: "Text output, low risk unless redirected",
+    tags: ["print", "text", "output"]
+  },
+  touch: {
+    description: "Create empty files or update timestamps",
+    category: "system",
+    risk: "low",
+    riskReason: "Creates empty files or updates metadata",
+    tags: ["create", "file", "timestamp"]
+  },
+  ln: {
+    description: "Create file links",
+    category: "system",
+    risk: "medium",
+    riskReason: "Symlinks can redirect file access",
+    tags: ["link", "symlink", "hardlink", "file"]
+  },
+  find: {
+    description: "Search for files in directory hierarchy",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file search with exec option",
+    tags: ["search", "files", "directory", "locate"]
+  },
+  grep: {
+    description: "Search file contents with patterns",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only content search",
+    tags: ["search", "pattern", "regex", "text", "match"]
+  },
+  sed: {
+    description: "Stream editor for text transformation",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can modify files in-place",
+    tags: ["edit", "transform", "text", "replace", "regex"]
+  },
+  awk: {
+    description: "Pattern scanning and text processing",
+    category: "system",
+    risk: "medium",
+    riskReason: "Turing-complete language, can execute system commands",
+    tags: ["text", "processing", "pattern", "columns", "transform"]
+  },
+  ps: {
+    description: "Report process status",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only process listing",
+    tags: ["process", "status", "list", "running"]
+  },
+  kill: {
+    description: "Send signals to processes",
+    category: "system",
+    risk: "high",
+    riskReason: "Can terminate critical processes",
+    tags: ["process", "signal", "terminate", "stop"]
+  },
+  top: {
+    description: "Display real-time process activity",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only system monitoring",
+    tags: ["process", "monitor", "cpu", "memory"]
+  },
+  df: {
+    description: "Report disk space usage",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only disk stats",
+    tags: ["disk", "space", "usage", "filesystem"]
+  },
+  du: {
+    description: "Estimate file space usage",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file size inspection",
+    tags: ["disk", "size", "usage", "file"]
+  },
+  mount: {
+    description: "Mount filesystems",
+    category: "system",
+    risk: "high",
+    riskReason: "Can attach external filesystems, requires root",
+    tags: ["filesystem", "attach", "volume", "disk"]
+  },
+  umount: {
+    description: "Unmount filesystems",
+    category: "system",
+    risk: "high",
+    riskReason: "Can detach active filesystems, requires root",
+    tags: ["filesystem", "detach", "volume", "disk"]
+  },
+  head: {
+    description: "Output first part of files",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file output",
+    tags: ["read", "file", "first", "lines", "output"]
+  },
+  tail: {
+    description: "Output last part of files",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file output",
+    tags: ["read", "file", "last", "lines", "output", "follow"]
+  },
+  wc: {
+    description: "Count lines, words, and bytes",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only counting",
+    tags: ["count", "lines", "words", "bytes", "file"]
+  },
+  sort: {
+    description: "Sort lines of text",
+    category: "system",
+    risk: "low",
+    riskReason: "Text processing, low risk",
+    tags: ["sort", "order", "text", "lines"]
+  },
+  uniq: {
+    description: "Filter adjacent duplicate lines",
+    category: "system",
+    risk: "low",
+    riskReason: "Text processing, low risk",
+    tags: ["unique", "duplicate", "filter", "text"]
+  },
+  tar: {
+    description: "Archive and compress files",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can overwrite files during extraction",
+    tags: ["archive", "compress", "extract", "backup", "gzip"]
+  },
+  xargs: {
+    description: "Build and execute commands from stdin",
+    category: "system",
+    risk: "medium",
+    riskReason: "Executes commands with piped arguments",
+    tags: ["execute", "pipe", "arguments", "build"]
+  },
+  tee: {
+    description: "Read stdin and write to files and stdout",
+    category: "system",
+    risk: "low",
+    riskReason: "Writes output to files",
+    tags: ["output", "write", "pipe", "file"]
+  },
+  env: {
+    description: "Display or set environment variables",
+    category: "system",
+    risk: "low",
+    riskReason: "Can expose environment variables including secrets",
+    tags: ["environment", "variables", "config"]
+  },
+  printenv: {
+    description: "Print environment variables",
+    category: "system",
+    risk: "low",
+    riskReason: "Can expose environment variables including secrets",
+    tags: ["environment", "variables", "display"]
+  },
+  which: {
+    description: "Locate a command",
+    category: "system",
+    risk: "info",
+    riskReason: "Read-only path lookup",
+    tags: ["locate", "path", "command", "binary"]
+  },
+  whoami: {
+    description: "Print current user name",
+    category: "system",
+    risk: "info",
+    riskReason: "Read-only user info",
+    tags: ["user", "identity", "login"]
+  },
+  uname: {
+    description: "Print system information",
+    category: "system",
+    risk: "info",
+    riskReason: "Read-only system info",
+    tags: ["system", "kernel", "os", "info"]
+  },
+  date: {
+    description: "Display or set date and time",
+    category: "system",
+    risk: "info",
+    riskReason: "Read-only time display",
+    tags: ["time", "date", "clock"]
+  },
+  sudo: {
+    description: "Execute command as superuser",
+    category: "system",
+    risk: "high",
+    riskReason: "Full root privilege escalation",
+    tags: ["root", "superuser", "privilege", "admin", "elevate"]
+  },
+  crontab: {
+    description: "Schedule periodic commands",
+    category: "system",
+    risk: "high",
+    riskReason: "Can schedule persistent background tasks",
+    tags: ["schedule", "cron", "periodic", "job", "task"]
+  },
+  // ── Language Runtimes ──────────────────────────────────────
+  node: {
+    description: "Node.js JavaScript runtime",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with network access",
+    tags: ["javascript", "runtime", "execute", "v8", "server"]
+  },
+  python: {
+    description: "Python interpreter",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with full system access",
+    tags: ["python", "runtime", "execute", "script", "interpreter"]
+  },
+  python3: {
+    description: "Python 3 interpreter",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with full system access",
+    tags: ["python", "runtime", "execute", "script", "interpreter"]
+  },
+  ruby: {
+    description: "Ruby interpreter",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with full system access",
+    tags: ["ruby", "runtime", "execute", "script", "interpreter"]
+  },
+  perl: {
+    description: "Perl interpreter",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with full system access",
+    tags: ["perl", "runtime", "execute", "script", "interpreter"]
+  },
+  java: {
+    description: "Java application launcher",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary JVM code",
+    tags: ["java", "jvm", "runtime", "execute", "jar"]
+  },
+  go: {
+    description: "Go programming language tool",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can compile and run arbitrary Go code",
+    tags: ["golang", "compile", "runtime", "build", "execute"]
+  },
+  rustc: {
+    description: "Rust compiler",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Compiles code that runs with full system access",
+    tags: ["rust", "compile", "build"]
+  },
+  deno: {
+    description: "Secure JavaScript/TypeScript runtime",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute code, sandboxed by default but flags allow access",
+    tags: ["javascript", "typescript", "runtime", "execute", "secure"]
+  },
+  bun: {
+    description: "Fast JavaScript runtime and toolkit",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with network access",
+    tags: ["javascript", "typescript", "runtime", "execute", "fast"]
+  },
+  php: {
+    description: "PHP interpreter",
+    category: "language-runtime",
+    risk: "medium",
+    riskReason: "Can execute arbitrary code with full system access",
+    tags: ["php", "runtime", "execute", "script", "web"]
+  },
+  // ── Version Control ────────────────────────────────────────
+  git: {
+    description: "Distributed version control",
+    category: "network",
+    risk: "medium",
+    riskReason: "Network ops can access remote repos and run hooks",
+    tags: ["vcs", "clone", "push", "pull", "repository", "commit", "branch"]
+  },
+  svn: {
+    description: "Subversion version control",
+    category: "network",
+    risk: "medium",
+    riskReason: "Network access to remote repositories",
+    tags: ["vcs", "checkout", "repository", "subversion"]
+  },
+  // ── Container & Orchestration ──────────────────────────────
+  docker: {
+    description: "Container runtime and management",
+    category: "system",
+    risk: "high",
+    riskReason: "Can run containers with host access and mount volumes",
+    tags: ["container", "image", "build", "run", "volume", "compose"]
+  },
+  "docker-compose": {
+    description: "Multi-container Docker orchestration",
+    category: "system",
+    risk: "high",
+    riskReason: "Can start multiple containers with host access",
+    tags: ["container", "compose", "orchestrate", "multi-container"]
+  },
+  kubectl: {
+    description: "Kubernetes cluster management",
+    category: "system",
+    risk: "high",
+    riskReason: "Full cluster access \u2014 can deploy, delete, and modify workloads",
+    tags: ["kubernetes", "k8s", "cluster", "deploy", "pods", "orchestrate"]
+  },
+  helm: {
+    description: "Kubernetes package manager",
+    category: "package-manager",
+    risk: "high",
+    riskReason: "Can install and modify Kubernetes deployments",
+    tags: ["kubernetes", "k8s", "charts", "deploy", "install"]
+  },
+  podman: {
+    description: "Daemonless container engine",
+    category: "system",
+    risk: "high",
+    riskReason: "Can run containers with host access",
+    tags: ["container", "image", "build", "run", "rootless"]
+  },
+  // ── Infrastructure & Cloud ─────────────────────────────────
+  terraform: {
+    description: "Infrastructure as code tool",
+    category: "system",
+    risk: "high",
+    riskReason: "Can create, modify, and destroy cloud infrastructure",
+    tags: ["iac", "cloud", "infrastructure", "provision", "hcl"]
+  },
+  aws: {
+    description: "AWS command line interface",
+    category: "network",
+    risk: "high",
+    riskReason: "Full AWS account access \u2014 can modify any service",
+    tags: ["cloud", "amazon", "s3", "ec2", "lambda", "infrastructure"]
+  },
+  gcloud: {
+    description: "Google Cloud CLI",
+    category: "network",
+    risk: "high",
+    riskReason: "Full GCP access \u2014 can modify any service",
+    tags: ["cloud", "google", "gcp", "infrastructure"]
+  },
+  az: {
+    description: "Azure command line interface",
+    category: "network",
+    risk: "high",
+    riskReason: "Full Azure access \u2014 can modify any service",
+    tags: ["cloud", "azure", "microsoft", "infrastructure"]
+  },
+  // ── Build Tools ────────────────────────────────────────────
+  make: {
+    description: "Build automation tool",
+    category: "system",
+    risk: "medium",
+    riskReason: "Executes Makefile targets which can run arbitrary commands",
+    tags: ["build", "compile", "automation", "makefile"]
+  },
+  cmake: {
+    description: "Cross-platform build system generator",
+    category: "system",
+    risk: "medium",
+    riskReason: "Generates build files that can run arbitrary commands",
+    tags: ["build", "compile", "generate", "cross-platform"]
+  },
+  nx: {
+    description: "Monorepo build system",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can run arbitrary scripts defined in project configuration",
+    tags: ["monorepo", "build", "workspace", "tasks"]
+  },
+  // ── Editors / Utilities ────────────────────────────────────
+  vi: {
+    description: "Visual text editor",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can execute shell commands from within editor",
+    tags: ["editor", "text", "file", "edit"]
+  },
+  vim: {
+    description: "Vi IMproved text editor",
+    category: "system",
+    risk: "medium",
+    riskReason: "Can execute shell commands from within editor",
+    tags: ["editor", "text", "file", "edit"]
+  },
+  nano: {
+    description: "Simple terminal text editor",
+    category: "system",
+    risk: "low",
+    riskReason: "File editing only, no command execution",
+    tags: ["editor", "text", "file", "edit", "simple"]
+  },
+  less: {
+    description: "File pager \u2014 view file contents",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file viewing",
+    tags: ["view", "pager", "read", "file"]
+  },
+  more: {
+    description: "File pager",
+    category: "system",
+    risk: "low",
+    riskReason: "Read-only file viewing",
+    tags: ["view", "pager", "read", "file"]
+  }
+};
+function searchCatalog(query, entries = COMMAND_CATALOG, limit = 20) {
+  const q = query.toLowerCase().trim();
+  if (!q) {
+    return Object.entries(entries).slice(0, limit).map(([name, entry]) => ({ name, entry, score: 0 }));
+  }
+  const tokens = q.split(/\s+/);
+  const results = [];
+  for (const [name, entry] of Object.entries(entries)) {
+    let totalScore = 0;
+    const nameLower = name.toLowerCase();
+    const descLower = entry.description.toLowerCase();
+    for (const token of tokens) {
+      let tokenScore = 0;
+      if (nameLower === token) {
+        tokenScore = 100;
+      } else if (nameLower.startsWith(token)) {
+        tokenScore = 60;
+      } else if (nameLower.includes(token)) {
+        tokenScore = 40;
+      }
+      for (const tag of entry.tags) {
+        const tagLower = tag.toLowerCase();
+        if (tagLower === token) {
+          tokenScore = Math.max(tokenScore, 30);
+        } else if (tagLower.includes(token)) {
+          tokenScore = Math.max(tokenScore, 15);
+        }
+      }
+      if (descLower.includes(token)) {
+        tokenScore = Math.max(tokenScore, 10);
+      }
+      totalScore += tokenScore;
+    }
+    if (totalScore > 0) {
+      results.push({ name, entry, score: totalScore });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+
+// libs/shield-ipc/src/constants.ts
+var DEFAULT_PORT = 5200;
+var DEFAULT_HOST = "127.0.0.1";
+var CUSTOM_HOSTNAME = "agen.shield";
+var CONFIG_DIR = ".agenshield";
+var CONFIG_FILE = "config.json";
+var PID_FILE = "daemon.pid";
+var LOG_FILE = "daemon.log";
+var STATE_FILE = "state.json";
+var VAULT_FILE = "vault.enc";
+var AGENCO_DIR = "agenco";
+var POLICIES_DIR = "policies";
+var USERS_DIR = "users";
+var MARKETPLACE_DIR = "marketplace";
+var CALLBACK_PORT = 9876;
+var MCP_GATEWAY = "https://mcp.marketplace.frontegg.com";
+var MARKETPLACE_API = "https://my.mcp.marketplace.frontegg.com";
+var API_PREFIX = "/api";
+var ENDPOINTS = {
+  HEALTH: "/health",
+  STATUS: "/status",
+  CONFIG: "/config",
+  POLICIES: "/policies",
+  SECURITY: "/security"
+};
+var SSE_PREFIX = "/sse";
+var SSE_ENDPOINTS = {
+  /** All events stream */
+  EVENTS: "/sse/events",
+  /** Security events only */
+  SECURITY: "/sse/events/security",
+  /** Broker events only */
+  BROKER: "/sse/events/broker",
+  /** API traffic events only */
+  API: "/sse/events/api"
+};
+export {
+  AGENCO_DIR,
+  API_PREFIX,
+  AgenCoAuthCallbackRequestSchema,
+  AgenCoAuthCallbackResponseSchema,
+  AgenCoAuthStartRequestSchema,
+  AgenCoAuthStartResponseSchema,
+  AgenCoAuthStatusResponseSchema,
+  AgenCoConnectIntegrationRequestSchema,
+  AgenCoConnectIntegrationResponseSchema,
+  AgenCoConnectedIntegrationSchema,
+  AgenCoConnectedIntegrationsResponseSchema,
+  AgenCoIntegrationActionSchema,
+  AgenCoIntegrationSchema,
+  AgenCoIntegrationsListRequestSchema,
+  AgenCoIntegrationsListResponseSchema,
+  AgenCoSecretsSchema,
+  AgenCoStateSchema,
+  AgenCoToolListRequestSchema,
+  AgenCoToolListResponseSchema,
+  AgenCoToolRunRequestSchema,
+  AgenCoToolRunResponseSchema,
+  AgenCoToolSchema,
+  AgenCoToolSearchRequestSchema,
+  AuthConfigSchema,
+  AuthStatusResponseSchema,
+  BACKUP_CONFIG,
+  BrokerErrorSchema,
+  BrokerRequestSchema,
+  BrokerResponseSchema,
+  CALLBACK_PORT,
+  COMMAND_CATALOG,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CUSTOM_HOSTNAME,
+  ChangePasscodeRequestSchema,
+  ChangePasscodeResponseSchema,
+  ChannelRestrictionSchema,
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_CHANNEL_RESTRICTIONS,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  DaemonConfigSchema,
+  DaemonStateSchema,
+  ENDPOINTS,
+  EnvInjectionRuleSchema,
+  ExecParamsSchema,
+  FileListParamsSchema,
+  FileReadParamsSchema,
+  FileWriteParamsSchema,
+  FsConstraintsSchema,
+  GroupDefinitionSchema,
+  GroupStateSchema,
+  HttpRequestParamsSchema,
+  InstallationConfigSchema,
+  InstallationStateSchema,
+  LOG_FILE,
+  LockRequestSchema,
+  LockResponseSchema,
+  MARKETPLACE_API,
+  MARKETPLACE_DIR,
+  MCP_GATEWAY,
+  NetworkConstraintsSchema,
+  OpenUrlParamsSchema,
+  OperationTypeSchema,
+  PID_FILE,
+  POLICIES_DIR,
+  PasscodeDataSchema,
+  PasscodeProtectionStateSchema,
+  PathsConfigSchema,
+  PingParamsSchema,
+  PolicyCheckParamsSchema,
+  PolicyConfigSchema,
+  PolicyConfigurationSchema,
+  PolicyEvaluationResultSchema,
+  PolicyRuleSchema,
+  SSE_ENDPOINTS,
+  SSE_PREFIX,
+  STATE_FILE,
+  SecretInjectParamsSchema,
+  SessionSchema,
+  SetupPasscodeRequestSchema,
+  SetupPasscodeResponseSchema,
+  ShieldConfigSchema,
+  SystemStateSchema,
+  USERS_DIR,
+  UnlockRequestSchema,
+  UnlockResponseSchema,
+  UserConfigSchema,
+  UserDefinitionSchema,
+  UserStateSchema,
+  VAULT_FILE,
+  VaultConfigSchema,
+  VaultContentsSchema,
+  searchCatalog
+};