AgentCompany/src/main/ipc-core-read-handlers.ts

import { dialog, nativeTheme, shell } from "electron";
import { join } from "node:path";
import { z } from "zod";
import {
  IPC_CHANNELS,
  connectorInputSchema,
  connectorModelPoolQuerySchema,
  entityGetterSchema,
  metricsQuerySchema,
  settingsSchema,
} from "@shared/contracts";
import { fail, ok, type RegisterCoreHandlersDependencies } from "./ipc-core-common";
import { logAppError } from "./errors/index.js";

export function registerCoreReadHandlers({
  registerHandle,
  db,
  ensureCompanyExists,
  publishDomainChanged,
  checkForUpdates,
  resetAfterRestore,
  listConnectorModels,
  logger,
}: Pick<
  RegisterCoreHandlersDependencies,
  | "registerHandle"
  | "db"
  | "ensureCompanyExists"
  | "publishDomainChanged"
  | "checkForUpdates"
  | "resetAfterRestore"
  | "listConnectorModels"
  | "logger"
>) {
  registerHandle(IPC_CHANNELS.loadSnapshot, () => ok(db.snap.listRendererSnapshot()));

  registerHandle(IPC_CHANNELS.pickDirectory, async () => {
    const result = await dialog.showOpenDialog({
      properties: ["openDirectory", "createDirectory"],
    });
    return ok(result.canceled ? null : (result.filePaths[0] ?? null));
  });

  registerHandle(IPC_CHANNELS.openPath, async (_event, targetPath) => {
    if (typeof targetPath !== "string" || targetPath.length === 0) {
      return fail("INVALID_PATH", "A valid path is required.");
    }
    if (!db.settings.canOpenPath(targetPath)) {
      return fail("OPEN_PATH_FORBIDDEN", "The requested path is outside the managed desktop workspace.");
    }
    const error = await shell.openPath(targetPath);
    return error ? fail("OPEN_PATH_FAILED", error) : ok(true);
  });

  /**
   * openWorkProduct resolves a work_product row to a concrete absolute
   * path (or URL) before handing off to the OS shell. The DocumentCenter
   * can no longer forward `externalId` straight into `openPath`: that
   * column stores a workspace-relative path so artifacts survive a
   * workspace-root move, but `shell.openPath` wants an absolute managed
   * path. The DB resolver joins the work_product back to its originating
   * task → workspace (or run → workspace for taskless runs) so the path
   * we hand to the shell is always inside the currently-mounted managed
   * tree and passes `canOpenPath` validation.
   */
  registerHandle(IPC_CHANNELS.openWorkProduct, async (_event, payload) => {
    const parsed = entityGetterSchema.safeParse(payload);
    if (!parsed.success) return fail("INVALID_PAYLOAD", "openWorkProduct requires { companyId, id }.");
    const companyError = ensureCompanyExists(parsed.data.companyId);
    if (companyError) return companyError;
    const target = db.documentsMod.resolveWorkProductTarget(parsed.data.id, parsed.data.companyId);
    if (!target) return fail("WORK_PRODUCT_NOT_FOUND", "Work product not found or its workspace is unresolved.");
    if (target.kind === "url") {
      const error = await shell.openExternal(target.value).then(() => "").catch((err: unknown) => err instanceof Error ? err.message : String(err));
      return error ? fail("OPEN_PATH_FAILED", error) : ok(true);
    }
    if (!db.settings.canOpenPath(target.value)) {
      return fail("OPEN_PATH_FORBIDDEN", "The requested path is outside the managed desktop workspace.");
    }
    const error = await shell.openPath(target.value);
    return error ? fail("OPEN_PATH_FAILED", error) : ok(true);
  });

  registerHandle(IPC_CHANNELS.backupProfile, async () => {
    const result = await dialog.showOpenDialog({
      properties: ["openDirectory", "createDirectory"],
    });
    if (result.canceled || result.filePaths.length === 0) {
      return ok(null);
    }
    const backupPath = join(result.filePaths[0]!, `agentcompany-backup-${Date.now()}`);
    await db.backupMod.exportBackup(backupPath);
    return ok(backupPath);
  });

  registerHandle(IPC_CHANNELS.restoreProfile, async () => {
    const hasActiveRuns = db.snap.listSnapshot().runs.some((run: { status: string }) => run.status === "queued" || run.status === "running");
    if (hasActiveRuns) {
      return fail("RESTORE_BLOCKED", "Stop all active runs before restoring a profile backup.");
    }
    const result = await dialog.showOpenDialog({
      properties: ["openDirectory"],
    });
    if (result.canceled || result.filePaths.length === 0) {
      return ok(false);
    }
    await db.backupMod.restoreFromBackup(result.filePaths[0]!);
    resetAfterRestore();
    publishDomainChanged();
    return ok(true);
  });

  registerHandle(IPC_CHANNELS.updateSettings, async (_event, payload) => {
    const parsed = settingsSchema.parse(payload);
    db.settings.updateSettings(parsed);
    if (parsed.theme) {
      nativeTheme.themeSource = parsed.theme;
    }
    publishDomainChanged();
    return ok(true);
  });

  registerHandle(IPC_CHANNELS.checkForUpdates, async () => {
    // Invocation via IPC only happens when the user opens Settings and clicks
    // "Check for updates". Pass manual:true so the Up-to-Date toast fires.
    return ok(await checkForUpdates({ manual: true }));
  });

  registerHandle(IPC_CHANNELS.listConnectorModels, async (_event, connectorId) => {
    try {
      const parsed = connectorInputSchema.shape.id.parse(connectorId);
      return ok(await listConnectorModels(parsed));
    } catch (err) {
      logAppError(logger, err, {
        kind: "upstream",
        code: "ipc.list_connector_models.failed",
        message: `listConnectorModels failed for connector ${String(connectorId)}`,
        context: { connectorId },
      }, "warn");
      return ok([]);
    }
  });

  registerHandle(IPC_CHANNELS.getConnectorDisabledModels, (_event, payload) => {
    try {
      const parsed = connectorModelPoolQuerySchema.parse(payload);
      return ok(db.settings.getDisabledModels(parsed.companyId, parsed.connectorId));
    } catch (err) {
      logAppError(logger, err, {
        kind: "user_input",
        code: "ipc.get_connector_disabled_models.invalid_payload",
        message: "getConnectorDisabledModels rejected payload (schema parse failed)",
      }, "warn");
      return ok([]);
    }
  });

  registerHandle(IPC_CHANNELS.getCompanyMetrics, (_event, payload) => {
    const input = metricsQuerySchema.parse(payload);
    const err = ensureCompanyExists(input.companyId);
    if (err) return err;
    return ok(db.company.getCompanyMetrics(input.companyId, input.days));
  });

  registerHandle(IPC_CHANNELS.getStandupReport, (_event, payload) => {
    const companyId = z.string().uuid().parse(payload);
    const err = ensureCompanyExists(companyId);
    if (err) return err;
    return ok(db.company.getStandupReport(companyId));
  });

  // --- Entity getters for granular IPC updates ---

  registerHandle(IPC_CHANNELS.getTask, (_event, payload) => {
    const parsed = entityGetterSchema.parse(payload);
    const companyError = ensureCompanyExists(parsed.companyId);
    if (companyError) return companyError;
    try {
      const task = db.entityCrud.getTask(parsed.id);
      if (task.companyId !== parsed.companyId) return fail("TASK_NOT_FOUND", "Task not found in current company.");
      return ok(task);
    } catch (err) {
      logAppError(logger, err, {
        kind: "recoverable",
        code: "ipc.get_task.lookup_failed",
        message: `getTask failed for id ${parsed.id}`,
        context: { taskId: parsed.id, companyId: parsed.companyId },
      }, "warn");
      return fail("TASK_NOT_FOUND", "Task not found.");
    }
  });

  registerHandle(IPC_CHANNELS.getAgent, (_event, payload) => {
    const parsed = entityGetterSchema.parse(payload);
    const companyError = ensureCompanyExists(parsed.companyId);
    if (companyError) return companyError;
    try {
      const agent = db.entityCrud.getAgent(parsed.id);
      if (agent.companyId !== parsed.companyId) return fail("AGENT_NOT_FOUND", "Agent not found in current company.");
      return ok(agent);
    } catch (err) {
      logAppError(logger, err, {
        kind: "recoverable",
        code: "ipc.get_agent.lookup_failed",
        message: `getAgent failed for id ${parsed.id}`,
        context: { agentId: parsed.id, companyId: parsed.companyId },
      }, "warn");
      return fail("AGENT_NOT_FOUND", "Agent not found.");
    }
  });

  registerHandle(IPC_CHANNELS.getRun, (_event, payload) => {
    const parsed = entityGetterSchema.parse(payload);
    const companyError = ensureCompanyExists(parsed.companyId);
    if (companyError) return companyError;
    try {
      const run = db.runs.getRun(parsed.id);
      if (run.companyId !== parsed.companyId) return fail("RUN_NOT_FOUND", "Run not found in current company.");
      return ok(run);
    } catch (err) {
      logAppError(logger, err, {
        kind: "recoverable",
        code: "ipc.get_run.lookup_failed",
        message: `getRun failed for id ${parsed.id}`,
        context: { runId: parsed.id, companyId: parsed.companyId },
      }, "warn");
      return fail("RUN_NOT_FOUND", "Run not found.");
    }
  });

  registerHandle(IPC_CHANNELS.getApproval, (_event, payload) => {
    const parsed = entityGetterSchema.parse(payload);
    const companyError = ensureCompanyExists(parsed.companyId);
    if (companyError) return companyError;
    try {
      const approval = db.approvalsMod.getApprovalRecord(parsed.id);
      if (approval.companyId !== parsed.companyId) return fail("APPROVAL_NOT_FOUND", "Approval not found in current company.");
      return ok(approval);
    } catch (err) {
      logAppError(logger, err, {
        kind: "recoverable",
        code: "ipc.get_approval.lookup_failed",
        message: `getApprovalRecord failed for id ${parsed.id}`,
        context: { approvalId: parsed.id, companyId: parsed.companyId },
      }, "warn");
      return fail("APPROVAL_NOT_FOUND", "Approval not found.");
    }
  });
}