@pinpatch/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1289 @@
+// src/contracts/artifacts.ts
+import { z as z2 } from "zod";
+
+// src/contracts/provider.ts
+import { z } from "zod";
+var ProviderNameSchema = z.enum(["codex", "claude", "cursor"]);
+var ProviderProgressStatusSchema = z.enum([
+  "queued",
+  "running",
+  "completed",
+  "error",
+  "cancelled",
+  "timeout"
+]);
+var ProviderTerminalStatusSchema = z.enum(["completed", "error", "cancelled", "timeout"]);
+var ProviderProgressSchema = z.object({
+  taskId: z.string().min(1),
+  sessionId: z.string().min(1),
+  status: ProviderProgressStatusSchema,
+  message: z.string().min(1),
+  percent: z.number().min(0).max(100).optional(),
+  timestamp: z.string().datetime()
+});
+var ProviderResultSchema = z.object({
+  taskId: z.string().min(1),
+  sessionId: z.string().min(1),
+  status: ProviderTerminalStatusSchema,
+  summary: z.string().min(1),
+  changedFiles: z.array(z.string()),
+  errorCode: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+var ProviderErrorCodes = {
+  ProviderUnavailable: "PROVIDER_UNAVAILABLE",
+  ProviderNotEnabled: "PROVIDER_NOT_ENABLED",
+  ProviderTimeout: "PROVIDER_TIMEOUT",
+  ProcessFailed: "PROVIDER_PROCESS_FAILED",
+  ValidationFailed: "PROVIDER_VALIDATION_FAILED",
+  Unknown: "UNKNOWN"
+};
+
+// src/contracts/artifacts.ts
+var PinStateSchema = z2.enum([
+  "idle",
+  "queued",
+  "running",
+  "completed",
+  "error",
+  "cancelled",
+  "timeout"
+]);
+var ViewportSchema = z2.object({
+  width: z2.number().int().positive(),
+  height: z2.number().int().positive()
+});
+var BoundingBoxSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  width: z2.number(),
+  height: z2.number()
+});
+var ElementDescriptorSchema = z2.object({
+  tag: z2.string().min(1),
+  role: z2.string().nullable().optional(),
+  text: z2.string().nullable().optional(),
+  attributes: z2.record(z2.union([z2.string(), z2.null()])),
+  boundingBox: BoundingBoxSchema
+});
+var UiChangePacketSchema = z2.object({
+  id: z2.string().min(1),
+  timestamp: z2.string().datetime(),
+  url: z2.string().min(1),
+  viewport: ViewportSchema,
+  element: ElementDescriptorSchema,
+  nearbyText: z2.array(z2.string()),
+  domSnippet: z2.string(),
+  computedStyleSummary: z2.record(z2.string()),
+  screenshotPath: z2.string().min(1),
+  userRequest: z2.string().min(1)
+});
+var TaskStatusSchema = z2.enum([
+  "created",
+  "queued",
+  "running",
+  "completed",
+  "error",
+  "cancelled",
+  "timeout"
+]);
+var TaskPinSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  body: z2.string().min(1)
+});
+var TaskRecordSchema = z2.object({
+  taskId: z2.string().min(1),
+  createdAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime(),
+  status: TaskStatusSchema,
+  url: z2.string().min(1),
+  viewport: ViewportSchema,
+  pin: TaskPinSchema,
+  uiChangePacket: UiChangePacketSchema,
+  screenshotPath: z2.string().min(1),
+  provider: ProviderNameSchema.optional(),
+  model: z2.string().optional(),
+  latestSessionId: z2.string().optional(),
+  sessions: z2.array(z2.string()),
+  summary: z2.string().optional(),
+  changedFiles: z2.array(z2.string()).default([]),
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
+});
+var SessionEventSchema = z2.object({
+  status: ProviderProgressStatusSchema,
+  message: z2.string().min(1),
+  percent: z2.number().min(0).max(100).optional(),
+  timestamp: z2.string().datetime()
+});
+var SessionRecordSchema = z2.object({
+  sessionId: z2.string().min(1),
+  taskId: z2.string().min(1),
+  provider: ProviderNameSchema,
+  model: z2.string().min(1),
+  status: ProviderProgressStatusSchema,
+  dryRun: z2.boolean(),
+  startedAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime(),
+  endedAt: z2.string().datetime().optional(),
+  events: z2.array(SessionEventSchema),
+  summary: z2.string().optional(),
+  changedFiles: z2.array(z2.string()).default([]),
+  errorCode: z2.string().optional(),
+  errorMessage: z2.string().optional()
+});
+var RuntimeLogLevelSchema = z2.enum(["debug", "info", "warn", "error"]);
+var RuntimeLogEventSchema = z2.object({
+  timestamp: z2.string().datetime(),
+  level: RuntimeLogLevelSchema,
+  component: z2.string().min(1),
+  taskId: z2.string().optional(),
+  sessionId: z2.string().optional(),
+  event: z2.string().min(1),
+  message: z2.string().min(1),
+  meta: z2.record(z2.unknown()).optional()
+});
+var PinpatchConfigSchema = z2.object({
+  provider: ProviderNameSchema.default("codex"),
+  model: z2.string().default("gpt-5.3-codex-spark"),
+  target: z2.number().int().positive().default(3e3),
+  debug: z2.boolean().default(false),
+  bridgePort: z2.number().int().positive().default(7331),
+  proxyPort: z2.number().int().positive().default(3030)
+});
+
+// src/contracts/bridge.ts
+import { z as z3 } from "zod";
+var CreateTaskRequestSchema = z3.object({
+  sessionId: z3.string().min(1),
+  url: z3.string().min(1),
+  viewport: ViewportSchema,
+  pin: z3.object({
+    x: z3.number(),
+    y: z3.number(),
+    body: z3.string().min(1)
+  }),
+  uiChangePacket: UiChangePacketSchema,
+  screenshotPath: z3.string().min(1),
+  screenshotDataUrl: z3.string().startsWith("data:image/").optional(),
+  clientTaskId: z3.string().min(1).optional()
+});
+var CreateTaskResponseSchema = z3.object({
+  taskId: z3.string(),
+  sessionId: z3.string(),
+  status: z3.literal("created"),
+  taskPath: z3.string(),
+  eventsUrl: z3.string()
+});
+var SubmitTaskRequestSchema = z3.object({
+  sessionId: z3.string().min(1),
+  provider: ProviderNameSchema,
+  model: z3.string().min(1),
+  dryRun: z3.boolean().default(false),
+  debug: z3.boolean().default(false),
+  followUpBody: z3.string().trim().min(1).optional()
+});
+var SubmitTaskResponseSchema = z3.object({
+  taskId: z3.string().min(1),
+  sessionId: z3.string().min(1),
+  status: z3.literal("queued"),
+  acceptedAt: z3.string().datetime(),
+  eventsUrl: z3.string().min(1)
+});
+var SseProgressEventSchema = z3.object({
+  type: z3.literal("progress"),
+  taskId: z3.string().min(1),
+  sessionId: z3.string().min(1),
+  status: z3.enum([
+    "queued",
+    "running",
+    "completed",
+    "error",
+    "cancelled",
+    "timeout"
+  ]),
+  message: z3.string().min(1),
+  percent: z3.number().min(0).max(100).optional(),
+  timestamp: z3.string().datetime()
+});
+var SseTerminalEventSchema = z3.object({
+  type: z3.literal("terminal"),
+  taskId: z3.string().min(1),
+  sessionId: z3.string().min(1),
+  status: z3.enum(["completed", "error", "cancelled", "timeout"]),
+  summary: z3.string().min(1),
+  changedFiles: z3.array(z3.string()),
+  errorCode: z3.string().optional(),
+  errorMessage: z3.string().optional(),
+  timestamp: z3.string().datetime()
+});
+var SseHeartbeatEventSchema = z3.object({
+  type: z3.literal("heartbeat"),
+  timestamp: z3.string().datetime()
+});
+var SseEventSchema = z3.union([
+  SseProgressEventSchema,
+  SseTerminalEventSchema,
+  SseHeartbeatEventSchema
+]);
+
+// src/config.ts
+import path from "path";
+import { promises as fs } from "fs";
+var DEFAULT_CONFIG = {
+  provider: "codex",
+  model: "gpt-5.3-codex-spark",
+  target: 3e3,
+  debug: false,
+  bridgePort: 7331,
+  proxyPort: 3030
+};
+var DEFAULT_CLAUDE_MODEL = "sonnet";
+var resolveConfigPath = (cwd) => path.join(cwd, ".pinpatch", "config.json");
+var omitUndefined = (value) => {
+  return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0));
+};
+var readConfigFile = async (cwd) => {
+  const configPath = resolveConfigPath(cwd);
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return PinpatchConfigSchema.partial().parse(parsed);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    return {};
+  }
+};
+var resolveConfig = async (cwd, overrides = {}) => {
+  const fileConfig = await readConfigFile(cwd);
+  const overrideConfig = omitUndefined(overrides);
+  const hasCliModelOverride = Object.prototype.hasOwnProperty.call(overrideConfig, "model");
+  const hasFileModel = Object.prototype.hasOwnProperty.call(fileConfig, "model");
+  const hasFileProvider = Object.prototype.hasOwnProperty.call(fileConfig, "provider");
+  const isBaselineFileModel = hasFileModel && hasFileProvider && fileConfig.model === DEFAULT_CONFIG.model && fileConfig.provider === DEFAULT_CONFIG.provider;
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig,
+    ...overrideConfig
+  };
+  const shouldUseClaudeDefault = merged.provider === "claude" && merged.model === DEFAULT_CONFIG.model && !hasCliModelOverride && (!hasFileModel || isBaselineFileModel);
+  if (shouldUseClaudeDefault) {
+    merged.model = DEFAULT_CLAUDE_MODEL;
+  }
+  return PinpatchConfigSchema.parse(merged);
+};
+var ensureConfigFile = async (cwd) => {
+  const configPath = resolveConfigPath(cwd);
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    return PinpatchConfigSchema.parse(JSON.parse(raw));
+  } catch {
+    await fs.writeFile(configPath, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+`, "utf8");
+    return DEFAULT_CONFIG;
+  }
+};
+var getConfigPath = resolveConfigPath;
+
+// src/storage/artifact-store.ts
+import path3 from "path";
+import { promises as fs3 } from "fs";
+
+// src/utils/fs.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import crypto from "crypto";
+var ensureDir = async (dirPath) => {
+  await fs2.mkdir(dirPath, { recursive: true });
+};
+var writeJsonAtomic = async (filePath, payload) => {
+  const dir = path2.dirname(filePath);
+  await ensureDir(dir);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`;
+  await fs2.writeFile(tempPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  await fs2.rename(tempPath, filePath);
+};
+var readJsonIfExists = async (filePath) => {
+  try {
+    const raw = await fs2.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+};
+var listJsonFiles = async (dirPath) => {
+  try {
+    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path2.join(dirPath, entry.name));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+};
+
+// src/storage/artifact-store.ts
+var ArtifactStore = class {
+  cwd;
+  rootDir;
+  tasksDir;
+  sessionsDir;
+  screenshotsDir;
+  runtimeDir;
+  logsDir;
+  configPath;
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.rootDir = path3.join(cwd, ".pinpatch");
+    this.tasksDir = path3.join(this.rootDir, "tasks");
+    this.sessionsDir = path3.join(this.rootDir, "sessions");
+    this.screenshotsDir = path3.join(this.rootDir, "screenshots");
+    this.runtimeDir = path3.join(this.rootDir, "runtime");
+    this.logsDir = path3.join(this.runtimeDir, "logs");
+    this.configPath = path3.join(this.rootDir, "config.json");
+  }
+  async ensureStructure() {
+    await ensureDir(this.tasksDir);
+    await ensureDir(this.sessionsDir);
+    await ensureDir(this.screenshotsDir);
+    await ensureDir(this.logsDir);
+    const existingConfig = await readJsonIfExists(this.configPath);
+    if (!existingConfig) {
+      await writeJsonAtomic(this.configPath, DEFAULT_CONFIG);
+    }
+  }
+  async ensureGitignoreEntry() {
+    const gitignorePath = path3.join(this.cwd, ".gitignore");
+    try {
+      const content = await fs3.readFile(gitignorePath, "utf8");
+      if (!content.includes(".pinpatch/")) {
+        await fs3.appendFile(gitignorePath, "\n.pinpatch/\n", "utf8");
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        await fs3.writeFile(gitignorePath, ".pinpatch/\n", "utf8");
+        return;
+      }
+      throw error;
+    }
+  }
+  getTaskPath(taskId) {
+    return path3.join(this.tasksDir, `${taskId}.json`);
+  }
+  getSessionPath(sessionId) {
+    return path3.join(this.sessionsDir, `${sessionId}.json`);
+  }
+  getRelativePath(absolutePath) {
+    return path3.relative(this.cwd, absolutePath);
+  }
+  async readConfig() {
+    const data = await readJsonIfExists(this.configPath);
+    return PinpatchConfigSchema.parse({ ...DEFAULT_CONFIG, ...data });
+  }
+  async writeConfig(config) {
+    const validated = PinpatchConfigSchema.parse(config);
+    await writeJsonAtomic(this.configPath, validated);
+  }
+  async createTask(task) {
+    const validated = TaskRecordSchema.parse(task);
+    await writeJsonAtomic(this.getTaskPath(validated.taskId), validated);
+    return validated;
+  }
+  async getTask(taskId) {
+    const raw = await readJsonIfExists(this.getTaskPath(taskId));
+    if (!raw) {
+      return void 0;
+    }
+    return TaskRecordSchema.parse(raw);
+  }
+  async updateTask(taskId, updater) {
+    const current = await this.getTask(taskId);
+    if (!current) {
+      throw new Error(`Task ${taskId} does not exist`);
+    }
+    const updated = TaskRecordSchema.parse(updater(current));
+    await writeJsonAtomic(this.getTaskPath(taskId), updated);
+    return updated;
+  }
+  async listTasks() {
+    const files = await listJsonFiles(this.tasksDir);
+    const rows = await Promise.all(
+      files.map(async (filePath) => {
+        const raw = await readJsonIfExists(filePath);
+        return raw ? TaskRecordSchema.parse(raw) : void 0;
+      })
+    );
+    return rows.filter((row) => row !== void 0);
+  }
+  async createSession(session) {
+    const validated = SessionRecordSchema.parse(session);
+    await writeJsonAtomic(this.getSessionPath(validated.sessionId), validated);
+    return validated;
+  }
+  async getSession(sessionId) {
+    const raw = await readJsonIfExists(this.getSessionPath(sessionId));
+    if (!raw) {
+      return void 0;
+    }
+    return SessionRecordSchema.parse(raw);
+  }
+  async updateSession(sessionId, updater) {
+    const current = await this.getSession(sessionId);
+    if (!current) {
+      throw new Error(`Session ${sessionId} does not exist`);
+    }
+    const updated = SessionRecordSchema.parse(updater(current));
+    await writeJsonAtomic(this.getSessionPath(sessionId), updated);
+    return updated;
+  }
+  async listSessions() {
+    const files = await listJsonFiles(this.sessionsDir);
+    const rows = await Promise.all(
+      files.map(async (filePath) => {
+        const raw = await readJsonIfExists(filePath);
+        return raw ? SessionRecordSchema.parse(raw) : void 0;
+      })
+    );
+    return rows.filter((row) => row !== void 0);
+  }
+  async writeScreenshot(taskId, screenshotDataUrl) {
+    const matches = screenshotDataUrl.match(/^data:image\/(png|jpeg|jpg);base64,(?<bytes>.+)$/);
+    if (!matches?.groups?.bytes) {
+      throw new Error("Invalid screenshot payload");
+    }
+    const filePath = path3.join(this.screenshotsDir, `${taskId}.png`);
+    const buffer = Buffer.from(matches.groups.bytes, "base64");
+    await fs3.writeFile(filePath, buffer);
+    return this.getRelativePath(filePath);
+  }
+  async appendLog(logPath, event) {
+    const validated = RuntimeLogEventSchema.parse(event);
+    await fs3.appendFile(logPath, `${JSON.stringify(validated)}
+`, "utf8");
+  }
+  async prune(options) {
+    const logsOlderThanDays = options?.logsOlderThanDays ?? 14;
+    const orphanSessionAgeHours = options?.orphanSessionAgeHours ?? 24;
+    const logFiles = await fs3.readdir(this.logsDir).catch(() => []);
+    const cutoffLogs = Date.now() - logsOlderThanDays * 24 * 60 * 60 * 1e3;
+    let removedLogs = 0;
+    for (const file of logFiles) {
+      const fullPath = path3.join(this.logsDir, file);
+      const stats = await fs3.stat(fullPath).catch(() => void 0);
+      if (!stats) {
+        continue;
+      }
+      if (stats.mtimeMs < cutoffLogs) {
+        await fs3.unlink(fullPath);
+        removedLogs += 1;
+      }
+    }
+    const tasks = await this.listTasks();
+    const taskIds = new Set(tasks.map((task) => task.taskId));
+    const sessions = await this.listSessions();
+    const cutoffSessions = Date.now() - orphanSessionAgeHours * 60 * 60 * 1e3;
+    let removedSessions = 0;
+    for (const session of sessions) {
+      const updatedAtMs = Date.parse(session.updatedAt);
+      const isOrphan = !taskIds.has(session.taskId);
+      if (isOrphan && updatedAtMs < cutoffSessions) {
+        await fs3.unlink(this.getSessionPath(session.sessionId));
+        removedSessions += 1;
+      }
+    }
+    return {
+      removedLogs,
+      removedSessions
+    };
+  }
+};
+
+// src/runtime/ids.ts
+import crypto2 from "crypto";
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var generateSessionId = () => crypto2.randomUUID();
+var generateTaskId = () => {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const suffix = crypto2.randomBytes(3).toString("hex");
+  return `${date}-${suffix}`;
+};
+
+// src/runtime/task-runner.ts
+var toMillis = (timestamp) => {
+  const value = Date.parse(timestamp);
+  return Number.isNaN(value) ? Date.now() : value;
+};
+var forceMonotonicTimestamp = (nextTs, lastTs) => {
+  const parsed = toMillis(nextTs);
+  if (parsed > lastTs) {
+    return { timestamp: new Date(parsed).toISOString(), millis: parsed };
+  }
+  const shifted = lastTs + 1;
+  return { timestamp: new Date(shifted).toISOString(), millis: shifted };
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "error",
+  "cancelled",
+  "timeout"
+]);
+var isTerminalStatus = (status) => TERMINAL_STATUSES.has(status);
+var TaskRunner = class {
+  cwd;
+  store;
+  logger;
+  eventBus;
+  getProviderAdapter;
+  defaultTimeoutMs;
+  dryRunTimeoutMs;
+  inFlight = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.store = options.store;
+    this.logger = options.logger;
+    this.eventBus = options.eventBus;
+    this.getProviderAdapter = options.getProviderAdapter;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 10 * 60 * 1e3;
+    this.dryRunTimeoutMs = options.dryRunTimeoutMs ?? 2 * 60 * 1e3;
+  }
+  key(taskId, sessionId) {
+    return `${taskId}:${sessionId}`;
+  }
+  async cancelTask(taskId, sessionId) {
+    const key = this.key(taskId, sessionId);
+    const entry = this.inFlight.get(key);
+    if (!entry) {
+      return;
+    }
+    await entry.adapter.cancelTask(taskId, sessionId);
+    this.logger.info("Cancel request forwarded to provider", {
+      component: "runner",
+      taskId,
+      sessionId,
+      event: "task.cancel"
+    });
+  }
+  async runTask(input) {
+    const { taskId, sessionId, provider, model, dryRun, debug } = input;
+    const task = await this.store.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} does not exist`);
+    }
+    const queuedTimestamp = nowIso();
+    await this.store.updateTask(taskId, (current) => ({
+      ...current,
+      status: "queued",
+      provider,
+      model,
+      latestSessionId: sessionId,
+      sessions: Array.from(/* @__PURE__ */ new Set([...current.sessions, sessionId])),
+      updatedAt: queuedTimestamp
+    }));
+    await this.store.createSession({
+      sessionId,
+      taskId,
+      provider,
+      model,
+      status: "queued",
+      dryRun,
+      startedAt: queuedTimestamp,
+      updatedAt: queuedTimestamp,
+      events: [
+        {
+          status: "queued",
+          message: "Task queued",
+          timestamp: queuedTimestamp
+        }
+      ],
+      changedFiles: []
+    });
+    const adapter = this.getProviderAdapter(provider);
+    if (!adapter) {
+      const unavailable = {
+        taskId,
+        sessionId,
+        status: "error",
+        summary: `Provider ${provider} is not available in this runtime`,
+        changedFiles: [],
+        errorCode: ProviderErrorCodes.ProviderUnavailable,
+        errorMessage: `Provider ${provider} was not registered`
+      };
+      await this.persistTerminalState(
+        task,
+        unavailable,
+        provider,
+        model,
+        dryRun
+      );
+      return unavailable;
+    }
+    const queuedEvent = {
+      type: "progress",
+      taskId,
+      sessionId,
+      status: "queued",
+      message: "Task queued",
+      timestamp: queuedTimestamp
+    };
+    this.eventBus.publish(taskId, sessionId, queuedEvent);
+    const key = this.key(taskId, sessionId);
+    this.inFlight.set(key, {
+      adapter,
+      startedAt: Date.now()
+    });
+    let lastProgressTime = toMillis(queuedTimestamp);
+    const timeoutMs = dryRun ? this.dryRunTimeoutMs : this.defaultTimeoutMs;
+    let terminalCommitted = false;
+    const handleProgress = async (event) => {
+      if (terminalCommitted) {
+        return;
+      }
+      const monotonic = forceMonotonicTimestamp(
+        event.timestamp,
+        lastProgressTime
+      );
+      lastProgressTime = monotonic.millis;
+      const normalizedEvent = {
+        ...event,
+        timestamp: monotonic.timestamp
+      };
+      await this.store.updateSession(sessionId, (session) => {
+        if (isTerminalStatus(session.status)) {
+          return session;
+        }
+        return {
+          ...session,
+          status: normalizedEvent.status,
+          updatedAt: normalizedEvent.timestamp,
+          events: [
+            ...session.events,
+            {
+              status: normalizedEvent.status,
+              message: normalizedEvent.message,
+              percent: normalizedEvent.percent,
+              timestamp: normalizedEvent.timestamp
+            }
+          ]
+        };
+      });
+      if (terminalCommitted) {
+        return;
+      }
+      if (normalizedEvent.status === "running" || normalizedEvent.status === "queued") {
+        await this.store.updateTask(taskId, (current) => {
+          if (isTerminalStatus(current.status)) {
+            return current;
+          }
+          return {
+            ...current,
+            status: normalizedEvent.status,
+            updatedAt: normalizedEvent.timestamp
+          };
+        });
+      }
+      if (terminalCommitted) {
+        return;
+      }
+      this.eventBus.publish(taskId, sessionId, {
+        type: "progress",
+        taskId,
+        sessionId,
+        status: normalizedEvent.status,
+        message: normalizedEvent.message,
+        percent: normalizedEvent.percent,
+        timestamp: normalizedEvent.timestamp
+      });
+      this.logger.debug(normalizedEvent.message, {
+        component: "runner",
+        taskId,
+        sessionId,
+        event: "task.progress",
+        meta: {
+          status: normalizedEvent.status,
+          percent: normalizedEvent.percent
+        }
+      });
+    };
+    try {
+      const providerTaskPromise = adapter.submitTask(
+        {
+          taskId,
+          sessionId,
+          task,
+          prompt: this.buildPrompt(task),
+          model,
+          dryRun,
+          debug,
+          cwd: this.cwd,
+          timeoutMs
+        },
+        (event) => {
+          void handleProgress(event);
+        }
+      );
+      let timeoutHandle;
+      const timeoutPromise = new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => {
+          resolve({
+            taskId,
+            sessionId,
+            status: "timeout",
+            summary: `Task timed out after ${timeoutMs}ms`,
+            changedFiles: [],
+            errorCode: ProviderErrorCodes.ProviderTimeout,
+            errorMessage: `Provider timed out after ${timeoutMs}ms`
+          });
+        }, timeoutMs);
+      });
+      const result = await Promise.race([providerTaskPromise, timeoutPromise]);
+      const normalizedResult = {
+        ...result,
+        taskId,
+        sessionId
+      };
+      terminalCommitted = true;
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      await this.persistTerminalState(
+        task,
+        normalizedResult,
+        provider,
+        model,
+        dryRun
+      );
+      this.inFlight.delete(key);
+      return normalizedResult;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown provider error";
+      const failedResult = {
+        taskId,
+        sessionId,
+        status: "error",
+        summary: "Provider execution failed",
+        changedFiles: [],
+        errorCode: ProviderErrorCodes.ProcessFailed,
+        errorMessage: message
+      };
+      terminalCommitted = true;
+      await this.persistTerminalState(
+        task,
+        failedResult,
+        provider,
+        model,
+        dryRun
+      );
+      this.inFlight.delete(key);
+      return failedResult;
+    }
+  }
+  buildPrompt(task) {
+    const selectedAttributes = JSON.stringify(
+      task.uiChangePacket.element.attributes
+    );
+    return [
+      "You are implementing a UI change request from Pinpatch.",
+      "Scope guardrails (must follow):",
+      "- Implement only the requested UI change.",
+      "- Treat the selected element as the primary edit target by default.",
+      "- Do not move the change to ancestors, siblings, or page/global wrappers unless the request explicitly asks for a page-level or app-wide change or the selected element cannot satisfy the request without broader changes.",
+      "- If the request is ambiguous, prefer changing the selected element directly.",
+      "- Do not edit, reformat, or reorganize unrelated files.",
+      "- Never revert, overwrite, or clean up unrelated repo changes (other agents may be editing in parallel).",
+      "- If unrelated files are modified or dirty, leave them untouched.",
+      "- If you cannot complete the request without touching unrelated areas, stop and report the exact blocker.",
+      `User request: ${task.pin.body}`,
+      `Page URL: ${task.url}`,
+      `Element: <${task.uiChangePacket.element.tag}> text="${task.uiChangePacket.element.text ?? ""}"`,
+      `Element attributes: ${selectedAttributes}`,
+      `Bounding box: ${JSON.stringify(task.uiChangePacket.element.boundingBox)}`,
+      `Nearby text: ${task.uiChangePacket.nearbyText.join(" | ")}`,
+      `DOM snippet: ${task.uiChangePacket.domSnippet}`,
+      `Computed style summary: ${JSON.stringify(task.uiChangePacket.computedStyleSummary)}`,
+      `Screenshot path: ${task.screenshotPath}`,
+      "Apply the change in local files.",
+      "Output format (must follow):",
+      "- For each modified file, print a line exactly as: CHANGED: <path>",
+      "- Final line must be exactly one sentence summarizing the changes made."
+    ].join("\n");
+  }
+  async persistTerminalState(task, result, provider, model, dryRun) {
+    const finishedAt = nowIso();
+    await this.store.updateSession(result.sessionId, (session) => ({
+      ...session,
+      provider,
+      model,
+      dryRun,
+      status: result.status,
+      summary: result.summary,
+      changedFiles: result.changedFiles,
+      errorCode: result.errorCode,
+      errorMessage: result.errorMessage,
+      endedAt: finishedAt,
+      updatedAt: finishedAt,
+      events: [
+        ...session.events,
+        {
+          status: result.status,
+          message: result.summary,
+          timestamp: finishedAt
+        }
+      ]
+    }));
+    await this.store.updateTask(task.taskId, (current) => ({
+      ...current,
+      status: result.status,
+      updatedAt: finishedAt,
+      provider,
+      model,
+      summary: result.summary,
+      changedFiles: result.changedFiles,
+      errorCode: result.errorCode,
+      errorMessage: result.errorMessage
+    }));
+    this.eventBus.publish(task.taskId, result.sessionId, {
+      type: "terminal",
+      taskId: task.taskId,
+      sessionId: result.sessionId,
+      status: result.status,
+      summary: result.summary,
+      changedFiles: result.changedFiles,
+      errorCode: result.errorCode,
+      errorMessage: result.errorMessage,
+      timestamp: finishedAt
+    });
+    this.logger.info(result.summary, {
+      component: "runner",
+      taskId: task.taskId,
+      sessionId: result.sessionId,
+      event: "task.terminal",
+      meta: {
+        status: result.status,
+        changedFiles: result.changedFiles,
+        errorCode: result.errorCode
+      }
+    });
+  }
+};
+
+// src/bridge/event-bus.ts
+import { EventEmitter } from "events";
+var keyFor = (taskId, sessionId) => `${taskId}:${sessionId}`;
+var TaskEventBus = class {
+  emitter = new EventEmitter();
+  subscribe(taskId, sessionId, listener) {
+    const key = keyFor(taskId, sessionId);
+    this.emitter.on(key, listener);
+    return () => {
+      this.emitter.off(key, listener);
+    };
+  }
+  publish(taskId, sessionId, event) {
+    this.emitter.emit(keyFor(taskId, sessionId), event);
+  }
+};
+
+// src/bridge/server.ts
+import { createServer } from "http";
+import path4 from "path";
+import { promises as fs4 } from "fs";
+import express from "express";
+import cors from "cors";
+var sanitizeTaskId = (candidate) => candidate.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 64);
+var serializeSse = (eventName, payload) => {
+  return `event: ${eventName}
+data: ${JSON.stringify(payload)}
+
+`;
+};
+var fallbackOverlayScript = `
+(function(){
+  if (window.__PINPATCH_OVERLAY_FALLBACK__) return;
+  window.__PINPATCH_OVERLAY_FALLBACK__ = true;
+  console.warn('[pinpatch] overlay bundle is missing. Build apps/overlay first.');
+})();
+`;
+var resolveAvailableTaskId = async (store, initialTaskId) => {
+  if (initialTaskId) {
+    const candidate = sanitizeTaskId(initialTaskId);
+    const existing = await store.getTask(candidate);
+    if (!existing) {
+      return candidate;
+    }
+  }
+  let tries = 0;
+  while (tries < 10) {
+    const candidate = generateTaskId();
+    const existing = await store.getTask(candidate);
+    if (!existing) {
+      return candidate;
+    }
+    tries += 1;
+  }
+  throw new Error("Failed to allocate a unique task id");
+};
+var createBridgeServer = (options) => {
+  const app = express();
+  const eventBus = new TaskEventBus();
+  const taskRunner = new TaskRunner({
+    cwd: options.cwd,
+    store: options.store,
+    logger: options.logger,
+    eventBus,
+    getProviderAdapter: options.getProviderAdapter
+  });
+  app.use(cors());
+  app.use(express.json({ limit: "25mb" }));
+  app.get("/health", (_req, res) => {
+    res.status(200).json({ ok: true });
+  });
+  app.get("/overlay.js", async (_req, res) => {
+    const requestedPath = options.overlayScriptPath;
+    if (requestedPath) {
+      try {
+        const script = await fs4.readFile(path4.resolve(requestedPath), "utf8");
+        res.setHeader("content-type", "application/javascript; charset=utf-8");
+        res.status(200).send(script);
+        return;
+      } catch {
+        options.logger.warn(
+          "Overlay bundle not found, serving fallback overlay script",
+          {
+            component: "bridge",
+            event: "overlay.fallback",
+            meta: {
+              overlayScriptPath: requestedPath
+            }
+          }
+        );
+      }
+    }
+    res.setHeader("content-type", "application/javascript; charset=utf-8");
+    res.status(200).send(fallbackOverlayScript);
+  });
+  app.post("/api/tasks", async (req, res) => {
+    const parsed = CreateTaskRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({
+        error: "Invalid request",
+        details: parsed.error.flatten()
+      });
+      return;
+    }
+    const payload = parsed.data;
+    const taskId = await resolveAvailableTaskId(
+      options.store,
+      payload.clientTaskId
+    );
+    let screenshotPath = payload.screenshotPath;
+    if (payload.screenshotDataUrl) {
+      screenshotPath = await options.store.writeScreenshot(
+        taskId,
+        payload.screenshotDataUrl
+      );
+    }
+    const createdAt = nowIso();
+    const taskRecord = {
+      taskId,
+      createdAt,
+      updatedAt: createdAt,
+      status: "created",
+      url: payload.url,
+      viewport: payload.viewport,
+      pin: payload.pin,
+      uiChangePacket: {
+        ...payload.uiChangePacket,
+        screenshotPath,
+        userRequest: payload.pin.body
+      },
+      screenshotPath,
+      sessions: [payload.sessionId],
+      latestSessionId: payload.sessionId,
+      changedFiles: []
+    };
+    await options.store.createTask(taskRecord);
+    options.logger.info("Task created", {
+      component: "bridge",
+      taskId,
+      sessionId: payload.sessionId,
+      event: "task.created",
+      meta: {
+        screenshotPath
+      }
+    });
+    res.status(201).json({
+      taskId,
+      sessionId: payload.sessionId,
+      status: "created",
+      taskPath: `.pinpatch/tasks/${taskId}.json`,
+      eventsUrl: `/api/tasks/${taskId}/events?sessionId=${payload.sessionId}`
+    });
+  });
+  app.post("/api/tasks/:taskId/submit", async (req, res) => {
+    const taskId = String(req.params.taskId ?? "");
+    if (!taskId) {
+      res.status(400).json({ error: "taskId is required" });
+      return;
+    }
+    const task = await options.store.getTask(taskId);
+    if (!task) {
+      res.status(404).json({ error: "Task not found" });
+      return;
+    }
+    const parsed = SubmitTaskRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({
+        error: "Invalid request",
+        details: parsed.error.flatten()
+      });
+      return;
+    }
+    const payload = parsed.data;
+    if (payload.followUpBody) {
+      const updatedAt = nowIso();
+      const followUpBody = payload.followUpBody;
+      await options.store.updateTask(taskId, (current) => ({
+        ...current,
+        updatedAt,
+        pin: {
+          ...current.pin,
+          body: followUpBody
+        },
+        uiChangePacket: {
+          ...current.uiChangePacket,
+          userRequest: followUpBody
+        }
+      }));
+    }
+    void taskRunner.runTask({
+      taskId,
+      sessionId: payload.sessionId,
+      provider: payload.provider,
+      model: payload.model,
+      dryRun: payload.dryRun,
+      debug: payload.debug
+    }).catch((error) => {
+      options.logger.error("Provider task execution failed", {
+        component: "bridge",
+        taskId,
+        sessionId: payload.sessionId,
+        event: "task.run.error",
+        meta: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+    });
+    const acceptedAt = nowIso();
+    res.status(202).json({
+      taskId,
+      sessionId: payload.sessionId,
+      status: "queued",
+      acceptedAt,
+      eventsUrl: `/api/tasks/${taskId}/events?sessionId=${payload.sessionId}`
+    });
+  });
+  app.post("/api/tasks/:taskId/cancel", async (req, res) => {
+    const taskId = String(req.params.taskId ?? "");
+    const sessionId = String(req.body?.sessionId ?? "");
+    if (!taskId || !sessionId) {
+      res.status(400).json({ error: "taskId and sessionId are required" });
+      return;
+    }
+    await taskRunner.cancelTask(taskId, sessionId);
+    res.status(202).json({ taskId, sessionId, status: "cancelled" });
+  });
+  app.get("/api/tasks/:taskId/events", async (req, res) => {
+    const taskId = String(req.params.taskId ?? "");
+    const sessionId = String(req.query.sessionId ?? "");
+    if (!taskId || !sessionId) {
+      res.status(400).json({ error: "taskId and sessionId query params are required" });
+      return;
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+    const push = (event) => {
+      const type = event.type === "terminal" ? "terminal" : event.type === "heartbeat" ? "heartbeat" : "progress";
+      res.write(serializeSse(type, event));
+    };
+    push({
+      type: "heartbeat",
+      timestamp: nowIso()
+    });
+    const unsubscribe = eventBus.subscribe(taskId, sessionId, push);
+    const heartbeat = setInterval(() => {
+      push({
+        type: "heartbeat",
+        timestamp: nowIso()
+      });
+    }, 15e3);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+      res.end();
+    });
+  });
+  const server = createServer(app);
+  return {
+    app,
+    server,
+    eventBus,
+    taskRunner,
+    async start() {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port, () => {
+          server.off("error", reject);
+          resolve();
+        });
+      });
+      options.logger.info(
+        `Bridge listening on http://localhost:${options.port}`,
+        {
+          component: "bridge",
+          event: "bridge.started"
+        }
+      );
+    },
+    async stop() {
+      await new Promise((resolve) => {
+        server.close(() => resolve());
+      });
+      options.logger.info("Bridge stopped", {
+        component: "bridge",
+        event: "bridge.stopped"
+      });
+    }
+  };
+};
+
+// src/logging/logger.ts
+import os from "os";
+import path5 from "path";
+import { existsSync, statSync } from "fs";
+var redactValue = (value) => {
+  if (typeof value === "string") {
+    const home = os.homedir();
+    return value.replaceAll(home, "~").replace(/(Bearer\s+)[A-Za-z0-9._-]+/gi, "$1[REDACTED]").replace(/(token=)[^\s&]+/gi, "$1[REDACTED]");
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const output = {};
+    for (const [key, fieldValue] of Object.entries(value)) {
+      if (["token", "authorization", "auth", "apiKey", "apikey"].includes(key.toLowerCase())) {
+        output[key] = "[REDACTED]";
+      } else {
+        output[key] = redactValue(fieldValue);
+      }
+    }
+    return output;
+  }
+  return value;
+};
+var getDateKey = (dateIso) => dateIso.slice(0, 10);
+var resolveLogPath = (logsDir, timestamp, maxFileSizeBytes) => {
+  const dateKey = getDateKey(timestamp);
+  let index = 0;
+  while (true) {
+    const candidateName = index === 0 ? `${dateKey}.jsonl` : `${dateKey}-${index}.jsonl`;
+    const candidatePath = path5.join(logsDir, candidateName);
+    if (!existsSync(candidatePath)) {
+      return candidatePath;
+    }
+    const size = statSync(candidatePath).size;
+    if (size < maxFileSizeBytes) {
+      return candidatePath;
+    }
+    index += 1;
+  }
+};
+var createLogger = (options) => {
+  const { store, debugEnabled, component, maxFileSizeBytes = 2 * 1024 * 1024 } = options;
+  const emit = (level, message, details) => {
+    if (level === "debug" && !debugEnabled) {
+      return;
+    }
+    const timestamp = nowIso();
+    const payload = RuntimeLogEventSchema.parse({
+      timestamp,
+      level,
+      component: details?.component ?? component,
+      taskId: details?.taskId,
+      sessionId: details?.sessionId,
+      event: details?.event ?? "log",
+      message,
+      meta: redactValue(details?.meta ?? {})
+    });
+    const line = `[${payload.timestamp}] ${payload.level.toUpperCase()} ${payload.component}: ${payload.message}`;
+    if (level === "error") {
+      console.error(line);
+    } else if (level === "warn") {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+    const logPath = resolveLogPath(store.logsDir, timestamp, maxFileSizeBytes);
+    void store.appendLog(logPath, payload);
+  };
+  return {
+    debug: (message, details) => emit("debug", message, details),
+    info: (message, details) => emit("info", message, details),
+    warn: (message, details) => emit("warn", message, details),
+    error: (message, details) => emit("error", message, details)
+  };
+};
+export {
+  ArtifactStore,
+  BoundingBoxSchema,
+  CreateTaskRequestSchema,
+  CreateTaskResponseSchema,
+  DEFAULT_CONFIG,
+  ElementDescriptorSchema,
+  PinStateSchema,
+  PinpatchConfigSchema,
+  ProviderErrorCodes,
+  ProviderNameSchema,
+  ProviderProgressSchema,
+  ProviderProgressStatusSchema,
+  ProviderResultSchema,
+  ProviderTerminalStatusSchema,
+  RuntimeLogEventSchema,
+  RuntimeLogLevelSchema,
+  SessionEventSchema,
+  SessionRecordSchema,
+  SseEventSchema,
+  SseHeartbeatEventSchema,
+  SseProgressEventSchema,
+  SseTerminalEventSchema,
+  SubmitTaskRequestSchema,
+  SubmitTaskResponseSchema,
+  TaskEventBus,
+  TaskPinSchema,
+  TaskRecordSchema,
+  TaskRunner,
+  TaskStatusSchema,
+  UiChangePacketSchema,
+  ViewportSchema,
+  createBridgeServer,
+  createLogger,
+  ensureConfigFile,
+  generateSessionId,
+  generateTaskId,
+  getConfigPath,
+  nowIso,
+  readConfigFile,
+  resolveConfig
+};
+//# sourceMappingURL=index.js.map