codepiper 0.1.0

package/packages/daemon/src/notifications/pushNotifier.ts

@@ -0,0 +1,369 @@
+import type { EventBus } from "@codepiper/core";
+import webpush from "web-push";
+import type { IDatabase, PushSubscriptionRecord } from "../db/db";
+
+const DEFAULT_PUSH_SUBJECT = "mailto:push@codepiper.dev";
+const PUSH_ENABLED_ENV = "CODEPIPER_PUSH_ENABLED";
+const PUSH_PUBLIC_KEY_ENV = "CODEPIPER_PUSH_PUBLIC_KEY";
+const PUSH_PRIVATE_KEY_ENV = "CODEPIPER_PUSH_PRIVATE_KEY";
+const PUSH_SUBJECT_ENV = "CODEPIPER_PUSH_SUBJECT";
+
+type ConsoleLike = Pick<Console, "warn" | "error">;
+
+export interface NotificationCreatedEvent {
+  id: number;
+  sessionId: string;
+  eventType: string;
+  title: string;
+  body: string | null;
+  payload?: Record<string, unknown>;
+}
+
+export interface PushRuntimeStatus {
+  enabled: boolean;
+  configured: boolean;
+  reasons: string[];
+  publicKey: string | null;
+}
+
+export interface PushDeliveryResult {
+  attempted: number;
+  delivered: number;
+  expired: number;
+  failed: number;
+  skipped: boolean;
+  reason?: "not_available" | "no_subscriptions";
+}
+
+interface WebPushClient {
+  setVapidDetails(subject: string, publicKey: string, privateKey: string): void;
+  sendNotification(
+    subscription: {
+      endpoint: string;
+      expirationTime: number | null;
+      keys: { p256dh: string; auth: string };
+    },
+    payload?: string
+  ): Promise<unknown>;
+}
+
+type PushNotifierDatabase = Pick<IDatabase, "listPushSubscriptions" | "deletePushSubscription">;
+
+export interface PushNotifierOptions {
+  enabled?: boolean;
+  vapidPublicKey?: string | null;
+  vapidPrivateKey?: string | null;
+  vapidSubject?: string | null;
+  webPushClient?: WebPushClient;
+  logger?: ConsoleLike;
+}
+
+function toTrimmedEnv(value: string | null | undefined): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isNotificationCreatedEvent(value: unknown): value is NotificationCreatedEvent {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const payload = value.payload;
+  const payloadValid = payload === undefined || isRecord(payload);
+  return (
+    typeof value.id === "number" &&
+    typeof value.sessionId === "string" &&
+    typeof value.eventType === "string" &&
+    typeof value.title === "string" &&
+    (typeof value.body === "string" || value.body === null) &&
+    payloadValid
+  );
+}
+
+function isExpiredSubscriptionError(error: unknown): boolean {
+  if (!isRecord(error)) {
+    return false;
+  }
+  const statusCode = error.statusCode;
+  return statusCode === 404 || statusCode === 410;
+}
+
+function toWebPushSubscription(subscription: PushSubscriptionRecord): {
+  endpoint: string;
+  expirationTime: number | null;
+  keys: { p256dh: string; auth: string };
+} {
+  return {
+    endpoint: subscription.endpoint,
+    expirationTime: subscription.expirationTime ?? null,
+    keys: {
+      p256dh: subscription.keys.p256dh,
+      auth: subscription.keys.auth,
+    },
+  };
+}
+
+function resolveSessionLabel(event: NotificationCreatedEvent): string {
+  if (isRecord(event.payload) && typeof event.payload.sessionLabel === "string") {
+    const candidate = event.payload.sessionLabel.trim();
+    if (candidate.length > 0) {
+      return candidate;
+    }
+  }
+
+  return `session ${event.sessionId.slice(0, 8)}`;
+}
+
+function bodyIncludesSessionLabel(body: string, sessionLabel: string): boolean {
+  return body.toLocaleLowerCase().includes(sessionLabel.toLocaleLowerCase());
+}
+
+function ensureBodyIncludesSessionLabel(body: string | null, sessionLabel: string): string | null {
+  if (!(typeof body === "string" && body.trim().length > 0)) {
+    return null;
+  }
+
+  const normalized = body.trim();
+  if (bodyIncludesSessionLabel(normalized, sessionLabel)) {
+    return normalized;
+  }
+
+  return `${sessionLabel}: ${normalized}`;
+}
+
+function ensureTitleIncludesSessionLabel(title: string, sessionLabel: string): string {
+  if (bodyIncludesSessionLabel(title, sessionLabel)) {
+    return title;
+  }
+  return `${sessionLabel} · ${title}`;
+}
+
+function toNotificationPayload(event: NotificationCreatedEvent): string {
+  const sessionLabel = resolveSessionLabel(event);
+  const fallbackBody =
+    event.eventType === "session.turn_completed"
+      ? `${sessionLabel} is ready for your next prompt.`
+      : event.eventType === "session.permission_required"
+        ? `${sessionLabel} is waiting for your permission approval.`
+        : event.eventType === "session.input_required"
+          ? `${sessionLabel} is waiting for your input.`
+          : `${sessionLabel} has an update: ${event.eventType.replaceAll(/[._]+/g, " ")}`;
+  const body = ensureBodyIncludesSessionLabel(event.body, sessionLabel) ?? fallbackBody;
+  const title = ensureTitleIncludesSessionLabel(event.title, sessionLabel);
+  const payload = {
+    title,
+    body,
+    sessionId: event.sessionId,
+    sessionLabel,
+    notificationId: event.id,
+    url: `/sessions/${encodeURIComponent(event.sessionId)}/terminal`,
+    tag: `codepiper:notification:${event.id}`,
+  };
+  return JSON.stringify(payload);
+}
+
+export class PushNotifier {
+  private readonly db: PushNotifierDatabase;
+  private readonly eventBus: EventBus<Record<string, unknown>>;
+  private readonly logger: ConsoleLike;
+  private readonly webPushClient: WebPushClient;
+  private readonly enabled: boolean;
+  private readonly configured: boolean;
+  private readonly baseReasons: string[];
+  private readonly publicKey: string | null;
+  private unsubscribeNotificationCreated: (() => void) | null = null;
+  private pendingEvents: NotificationCreatedEvent[] = [];
+  private queueProcessing = false;
+
+  constructor(
+    db: PushNotifierDatabase,
+    eventBus: EventBus<Record<string, unknown>>,
+    options: PushNotifierOptions = {}
+  ) {
+    this.db = db;
+    this.eventBus = eventBus;
+    this.logger = options.logger ?? console;
+    this.webPushClient = options.webPushClient ?? webpush;
+    this.enabled = options.enabled ?? process.env[PUSH_ENABLED_ENV] === "1";
+    this.baseReasons = [];
+    this.publicKey = null;
+
+    if (!this.enabled) {
+      this.baseReasons.push("feature_disabled");
+      this.configured = false;
+      return;
+    }
+
+    const vapidPublicKey = toTrimmedEnv(
+      options.vapidPublicKey ?? process.env[PUSH_PUBLIC_KEY_ENV] ?? null
+    );
+    const vapidPrivateKey = toTrimmedEnv(
+      options.vapidPrivateKey ?? process.env[PUSH_PRIVATE_KEY_ENV] ?? null
+    );
+    const vapidSubject = toTrimmedEnv(
+      options.vapidSubject ?? process.env[PUSH_SUBJECT_ENV] ?? DEFAULT_PUSH_SUBJECT
+    );
+    this.publicKey = vapidPublicKey || null;
+
+    if (!vapidPublicKey) {
+      this.baseReasons.push("missing_vapid_public_key");
+    }
+    if (!vapidPrivateKey) {
+      this.baseReasons.push("missing_vapid_private_key");
+    }
+    if (!(vapidPublicKey && vapidPrivateKey)) {
+      this.logger.warn(
+        `[push] ${PUSH_ENABLED_ENV}=1 but VAPID keys are missing; push delivery disabled`
+      );
+      this.configured = false;
+      return;
+    }
+
+    try {
+      this.webPushClient.setVapidDetails(vapidSubject, vapidPublicKey, vapidPrivateKey);
+      this.configured = true;
+    } catch (error) {
+      this.logger.error("[push] Failed to configure VAPID details; push delivery disabled", error);
+      this.baseReasons.push("invalid_vapid_configuration");
+      this.configured = false;
+    }
+  }
+
+  getStatus(): PushRuntimeStatus {
+    return {
+      enabled: this.enabled,
+      configured: this.configured,
+      reasons: Array.from(new Set(this.baseReasons)),
+      publicKey: this.publicKey,
+    };
+  }
+
+  start(): void {
+    if (!(this.enabled && this.configured) || this.unsubscribeNotificationCreated) {
+      return;
+    }
+
+    this.unsubscribeNotificationCreated = this.eventBus.on("notification:created", (event) => {
+      if (!isNotificationCreatedEvent(event)) {
+        return;
+      }
+      this.pendingEvents.push(event);
+      void this.drainQueue();
+    });
+  }
+
+  stop(): void {
+    if (this.unsubscribeNotificationCreated) {
+      this.unsubscribeNotificationCreated();
+      this.unsubscribeNotificationCreated = null;
+    }
+    this.pendingEvents = [];
+  }
+
+  async sendTestNotification(params?: {
+    title?: string;
+    body?: string;
+    sessionId?: string;
+  }): Promise<PushDeliveryResult> {
+    if (!(this.enabled && this.configured)) {
+      return {
+        attempted: 0,
+        delivered: 0,
+        expired: 0,
+        failed: 0,
+        skipped: true,
+        reason: "not_available",
+      };
+    }
+
+    const subscriptions = this.db.listPushSubscriptions();
+    if (subscriptions.length === 0) {
+      return {
+        attempted: 0,
+        delivered: 0,
+        expired: 0,
+        failed: 0,
+        skipped: true,
+        reason: "no_subscriptions",
+      };
+    }
+
+    const event: NotificationCreatedEvent = {
+      id: Date.now(),
+      sessionId: params?.sessionId?.trim() || "push-test",
+      eventType: "session.turn_completed",
+      title: params?.title?.trim() || "CodePiper test notification",
+      body: params?.body?.trim() || "Push delivery is working.",
+    };
+
+    const payload = toNotificationPayload(event);
+    return this.deliverPayloadToSubscriptions(payload, subscriptions);
+  }
+
+  private async drainQueue(): Promise<void> {
+    if (this.queueProcessing) {
+      return;
+    }
+
+    this.queueProcessing = true;
+    try {
+      while (this.pendingEvents.length > 0) {
+        const event = this.pendingEvents.shift();
+        if (!event) {
+          continue;
+        }
+        await this.deliverEvent(event);
+      }
+    } finally {
+      this.queueProcessing = false;
+    }
+  }
+
+  private async deliverEvent(event: NotificationCreatedEvent): Promise<void> {
+    const subscriptions = this.db.listPushSubscriptions();
+    if (subscriptions.length === 0) {
+      return;
+    }
+
+    const payload = toNotificationPayload(event);
+    await this.deliverPayloadToSubscriptions(payload, subscriptions);
+  }
+
+  private async deliverPayloadToSubscriptions(
+    payload: string,
+    subscriptions: PushSubscriptionRecord[]
+  ): Promise<PushDeliveryResult> {
+    const result: PushDeliveryResult = {
+      attempted: subscriptions.length,
+      delivered: 0,
+      expired: 0,
+      failed: 0,
+      skipped: false,
+    };
+
+    await Promise.all(
+      subscriptions.map(async (subscription) => {
+        try {
+          await this.webPushClient.sendNotification(toWebPushSubscription(subscription), payload);
+          result.delivered += 1;
+        } catch (error) {
+          if (isExpiredSubscriptionError(error)) {
+            this.db.deletePushSubscription(subscription.endpoint);
+            result.expired += 1;
+            return;
+          }
+
+          result.failed += 1;
+          const statusCode =
+            isRecord(error) && typeof error.statusCode === "number" ? error.statusCode : "unknown";
+          this.logger.warn(`[push] Delivery failed for a subscription (status=${statusCode})`);
+        }
+      })
+    );
+
+    return result;
+  }
+}

package/packages/daemon/src/providers/codexAppServerScaffold.ts

@@ -0,0 +1,49 @@
+import type { ProviderBuildCommandArgs } from "./types";
+
+export interface CodexAppServerSpikeState {
+  configured: boolean;
+  enrolled: boolean;
+  mode: "tmux-cli-fallback";
+}
+
+const CODEX_HOST_ACCESS_RUNTIME_ARGS = [
+  "--sandbox",
+  "danger-full-access",
+  "-a",
+  "on-request",
+] as const;
+
+export function resolveCodexAppServerSpikeState(
+  args: Pick<ProviderBuildCommandArgs, "terminalFeatures">
+): CodexAppServerSpikeState {
+  const configured = args.terminalFeatures?.codexAppServerSpikeEnabled === true;
+  const enrolled = configured;
+
+  return {
+    configured,
+    enrolled,
+    // Scaffold phase: enrollment metadata exists, runtime remains tmux CLI.
+    // Intentionally boolean-only (no canary): CodePiper targets single-user deployments.
+    mode: "tmux-cli-fallback",
+  };
+}
+
+export function buildCodexCommand(args: ProviderBuildCommandArgs): string[] {
+  const command = ["codex"];
+  if (args.dangerousMode) {
+    command.push("--dangerously-bypass-approvals-and-sandbox");
+  } else if (args.codexHostAccessProfileEnabled) {
+    command.push(...CODEX_HOST_ACCESS_RUNTIME_ARGS);
+  }
+
+  if (args.providerResume) {
+    const mode = args.providerResume.mode === "fork" ? "fork" : "resume";
+    command.push(mode);
+    command.push(...args.providerArgs);
+    command.push(args.providerResume.providerSessionId);
+    return command;
+  }
+
+  command.push(...args.providerArgs);
+  return command;
+}

package/packages/daemon/src/providers/registry.ts

@@ -0,0 +1,111 @@
+import { type KnownProviderId, type ProviderId, SUPPORTED_PROVIDERS } from "@codepiper/core";
+import { generateOverlaySettings } from "@codepiper/provider-claude-code";
+import { buildCodexCommand } from "./codexAppServerScaffold";
+import type { ProviderDefinition } from "./types";
+
+const PROVIDERS: Record<KnownProviderId, ProviderDefinition> = {
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code",
+    runtime: "tmux",
+    capabilities: {
+      nativeHooks: true,
+      supportsDangerousMode: true,
+      supportsModelSwitch: true,
+      supportsTranscriptTailing: true,
+      supportsTmuxAdoption: true,
+      policyChannel: "native-hooks",
+      metricsChannel: "transcript",
+    },
+    launchHints: {
+      dangerousModeFlags: ["--dangerously-skip-permissions"],
+      resumeCommands: {
+        resume: "claude --resume {id}",
+        fork: "claude --resume {id} --fork-session",
+        idPlaceholder: "claude session id",
+      },
+    },
+    async prepareSession(args) {
+      const settingsPath = await generateOverlaySettings({
+        sessionId: args.sessionId,
+        socketPath: args.socketPath,
+        secret: args.secret,
+        outputDir: args.runtimeDir,
+        enableStatusline: false,
+      });
+
+      return {
+        settingsPath,
+        cleanupArtifacts: [
+          `${args.sessionId}.json`,
+          `${args.sessionId}.hook-forward.sh`,
+          `${args.sessionId}.statusline-forward.sh`,
+        ],
+      };
+    },
+    buildCommand(args) {
+      const command = ["claude"];
+      if (args.providerResume) {
+        command.push("--resume", args.providerResume.providerSessionId);
+        if (args.providerResume.mode === "fork") {
+          command.push("--fork-session");
+        }
+      } else {
+        command.push("--session-id", args.sessionId);
+      }
+      if (args.dangerousMode) {
+        command.push("--dangerously-skip-permissions");
+      }
+      if (args.settingsPath) {
+        command.push("--settings", args.settingsPath);
+      }
+      command.push(...args.providerArgs);
+      return command;
+    },
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    runtime: "tmux",
+    capabilities: {
+      nativeHooks: false,
+      supportsDangerousMode: true,
+      supportsModelSwitch: false,
+      supportsTranscriptTailing: false,
+      supportsTmuxAdoption: true,
+      policyChannel: "input-preflight",
+      metricsChannel: "pty",
+    },
+    launchHints: {
+      dangerousModeFlags: ["--dangerously-bypass-approvals-and-sandbox"],
+      resumeCommands: {
+        resume: "codex resume {id}",
+        fork: "codex fork {id}",
+        idPlaceholder: "019c7285-ba64-7462-bbfc-4227f3e24e88",
+      },
+    },
+    buildCommand(args) {
+      return buildCodexCommand(args);
+    },
+  },
+};
+
+export function listSupportedProviders(): KnownProviderId[] {
+  return [...SUPPORTED_PROVIDERS];
+}
+
+export function isProviderId(value: string): value is KnownProviderId {
+  return listSupportedProviders().includes(value as KnownProviderId);
+}
+
+export function getProviderDefinition(providerId: ProviderId): ProviderDefinition {
+  const definition = PROVIDERS[providerId as KnownProviderId];
+  if (!definition) {
+    throw new Error(`Unsupported provider: ${providerId}`);
+  }
+  return definition;
+}
+
+export function listProviderDefinitions(): ProviderDefinition[] {
+  return listSupportedProviders().map((providerId) => getProviderDefinition(providerId));
+}

package/packages/daemon/src/providers/types.ts

@@ -0,0 +1,82 @@
+import type { ProviderId } from "@codepiper/core";
+
+export type ProviderPolicyChannel = "native-hooks" | "input-preflight" | "none";
+export type ProviderMetricsChannel = "transcript" | "pty" | "none";
+
+export interface ProviderCapabilities {
+  nativeHooks: boolean;
+  supportsDangerousMode: boolean;
+  supportsModelSwitch: boolean;
+  supportsTranscriptTailing: boolean;
+  supportsTmuxAdoption: boolean;
+  policyChannel: ProviderPolicyChannel;
+  metricsChannel: ProviderMetricsChannel;
+}
+
+export interface ProviderResumeCommandHints {
+  /**
+   * Command template for standard resume mode.
+   * Use "{id}" placeholder for provider session id interpolation.
+   */
+  resume: string;
+  /**
+   * Optional command template for fork resume mode.
+   */
+  fork?: string;
+  /**
+   * Optional UI placeholder for provider session ids.
+   */
+  idPlaceholder?: string;
+}
+
+export interface ProviderLaunchHints {
+  /**
+   * Provider-native dangerous mode flags expected to be applied by daemon.
+   */
+  dangerousModeFlags: string[];
+  /**
+   * Optional resume/fork command preview templates for UI.
+   */
+  resumeCommands?: ProviderResumeCommandHints;
+}
+
+export interface ProviderPrepareSessionArgs {
+  sessionId: string;
+  runtimeDir: string;
+  socketPath: string;
+  secret: string;
+}
+
+export interface ProviderPrepareSessionResult {
+  settingsPath?: string;
+  cleanupArtifacts?: string[];
+}
+
+export type ProviderResumeMode = "resume" | "fork";
+
+export interface ProviderResumeTarget {
+  providerSessionId: string;
+  mode?: ProviderResumeMode;
+}
+
+export interface ProviderBuildCommandArgs {
+  sessionId: string;
+  settingsPath?: string;
+  providerArgs: string[];
+  dangerousMode: boolean;
+  providerResume?: ProviderResumeTarget;
+  codexHostAccessProfileEnabled?: boolean;
+  terminalFeatures?: {
+    codexAppServerSpikeEnabled?: boolean;
+  };
+}
+
+export interface ProviderDefinition {
+  id: ProviderId;
+  label: string;
+  runtime: "tmux" | "pty";
+  capabilities: ProviderCapabilities;
+  launchHints?: ProviderLaunchHints;
+  prepareSession?: (args: ProviderPrepareSessionArgs) => Promise<ProviderPrepareSessionResult>;
+  buildCommand: (args: ProviderBuildCommandArgs) => string[];
+}

package/packages/daemon/src/sessions/auditLogger.ts

@@ -0,0 +1,103 @@
+/**
+ * AuditLogger - Logs all policy decisions for audit trail and analysis
+ */
+
+import type { Database, GetPolicyDecisionsOptions, PolicyDecisionRecord } from "../db/db";
+import type { PolicyDecision } from "./policyTypes";
+
+export interface LogDecisionParams {
+  sessionId: string;
+  eventId?: number;
+  toolName: string;
+  args: Record<string, unknown>;
+  decision: PolicyDecision;
+  timestamp?: Date;
+}
+
+export interface DecisionStatistics {
+  total: number;
+  allow: number;
+  deny: number;
+  ask: number;
+}
+
+export class AuditLogger {
+  constructor(private db: Database) {}
+
+  /**
+   * Log a policy decision to the audit trail
+   */
+  logDecision(params: LogDecisionParams): number {
+    return this.db.insertPolicyDecision({
+      sessionId: params.sessionId,
+      eventId: params.eventId,
+      policyId: params.decision.policyId,
+      toolName: params.toolName,
+      args: params.args,
+      decision: params.decision.action,
+      reason: params.decision.reason,
+      timestamp: params.timestamp,
+    });
+  }
+
+  /**
+   * Get policy decisions for a session
+   */
+  getDecisions(sessionId: string, options?: GetPolicyDecisionsOptions): PolicyDecisionRecord[] {
+    return this.db.getPolicyDecisionsBySessionId(sessionId, options);
+  }
+
+  /**
+   * Export decisions in various formats
+   */
+  exportDecisions(sessionId: string, format: "json" | "csv"): string {
+    const decisions = this.getDecisions(sessionId);
+
+    if (format === "json") {
+      return JSON.stringify(
+        decisions.map((d) => ({
+          timestamp: d.timestamp.toISOString(),
+          toolName: d.toolName,
+          decision: d.decision,
+          reason: d.reason,
+          policyId: d.policyId,
+          ruleId: undefined, // Not stored in decision record
+          args: d.args,
+          eventId: d.eventId,
+        })),
+        null,
+        2
+      );
+    }
+
+    if (format === "csv") {
+      const header = "timestamp,toolName,decision,reason,policyId,args\n";
+      const rows = decisions
+        .map((d) => {
+          const timestamp = d.timestamp.toISOString();
+          const args = d.args ? JSON.stringify(d.args).replace(/"/g, '""') : "";
+          const reason = (d.reason ?? "").replace(/"/g, '""');
+          return `${timestamp},${d.toolName},${d.decision},"${reason}",${d.policyId ?? ""},"${args}"`;
+        })
+        .join("\n");
+
+      return `${header + rows}\n`;
+    }
+
+    throw new Error(`Unsupported export format: ${format}`);
+  }
+
+  /**
+   * Get decision statistics for a session
+   */
+  getStatistics(sessionId: string): DecisionStatistics {
+    const decisions = this.getDecisions(sessionId);
+
+    return {
+      total: decisions.length,
+      allow: decisions.filter((d) => d.decision === "allow").length,
+      deny: decisions.filter((d) => d.decision === "deny").length,
+      ask: decisions.filter((d) => d.decision === "ask").length,
+    };
+  }
+}