main.js · part 10

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js, part 10. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

connection reset

fetch failed

network error

other side closed

socket hang up

BcsAgentStoreTransport requires either `client` or `transport`.

Agent store write for ${e.relPath} sets both baseEtag and expectAbsent; they are mutually exclusive

Agent store write for ${e.relPath} carries an empty baseEtag

BCS presign write response missing requested file: ${n}

BCS multipart complete response repeated inputIndex ${t}

BCS multipart complete response relPath mismatch at inputIndex ${t}

BCS multipart abort response repeated inputIndex ${t}

BCS multipart abort response relPath mismatch at inputIndex ${t}

The operation was aborted

Agent store directory listing exceeded 10 pages

Agent store directory listing exceeded 10000 entries

Agent store directory listing exceeded 10000 entries

Agent store directory listing repeated a page token

Agent store delete for ${e.relPath} carries an empty baseEtag

BCS delete returned UNSPECIFIED status for ${t}

BCS delete returned an unknown status for ${t}: ${e.status}

agent store RPC canceled

agent store RPC deadline exceeded

BCS multipart write instruction is missing context

BCS multipart ${r} response returned out-of-range inputIndex ${t}

BCS multipart ${e.kind} response returned an invalid relPath at inputIndex ${e.inputIndex}

BCS multipart ${t} response missing result for inputIndex ${n}

BoundedConcurrencyQueue max must be a positive integer, got ${t}

BoundedConcurrencyQueue reservedForPriority must be a non-negative integer, got ${r}

Refusing to open sqlite under symlinked parent: ${e}

Refusing to open sqlite under non-directory parent: ${r}

Refusing to open symlinked path: ${e}

Refusing to open non-regular sqlite path: ${e}

Sqlite path became symlinked between open and verification: ${e}

Sqlite path inode drifted between open and verification (expected dev=${t.dev} ino=${t.ino}, got dev=${r.dev} ino=${r.ino}): ${e}

Refusing to create lockfile at symlinked path: ${e}

Unable to lstat parent directory ${t}: ${e instanceof Error?e.message:String(e)}

Parent directory became symlinked between open and verification: ${t}

Parent directory inode drifted between open and verification (expected dev=${e.dev} ino=${e.ino}, got dev=${r.dev} ino=${r.ino}): ${t}

Could not determine current uid for store lock

Unreadable agent store lockfile: ${e}

Invalid agent store lockfile JSON: ${e}

Invalid agent store lockfile contents: ${e}

Agent store lock is held by uid ${e.uid}, expected ${t.identity.uid}

Agent store lock is held by sid ${e.sid}, expected ${t.identity.sid}

Could not determine current Windows lock identity

${sn(e.from)} -> ${sn(e.to)} (${e.reason})

SELECT ${En} FROM files WHERE rel_path = ?

SELECT ${En} FROM files ORDER BY rel_path ASC

SELECT 1 AS ok FROM files
         WHERE state != 'tombstoned'
           AND rel_path >= ? AND rel_path < ?
         LIMIT 1

SELECT 1 AS ok FROM files WHERE state != 'tombstoned' LIMIT 1

SELECT 1 AS ok FROM files
         WHERE state != 'tombstoned'
           AND (rel_path = ? OR (rel_path >= ? AND rel_path < ?))
         LIMIT 1

        INSERT INTO files (
          rel_path,
          last_synced_sha,
          last_seen_etag,
          size,
          last_synced_ms,
          direction,
          state,
          tombstone_etag,
          deleted_at_ms,
          stat_size,
          stat_mtime_ns,
          stat_ctime_ns,
          stat_ino,
          stat_dev,
          stat_recorded_ms
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(rel_path) DO UPDATE SET
          last_synced_sha = excluded.last_synced_sha,
          last_seen_etag = excluded.last_seen_etag,
          size = excluded.size,
          last_synced_ms = excluded.last_synced_ms,
          direction = excluded.direction,
          state = excluded.state,
          tombstone_etag = excluded.tombstone_etag,
          deleted_at_ms = excluded.deleted_at_ms,
          stat_size = ${In},
          stat_mtime_ns = ${Tn("stat_mtime_ns")},
          stat_ctime_ns = ${Tn("stat_ctime_ns")},
          stat_ino = ${Tn("stat_ino")},
          stat_dev = ${Tn("stat_dev")},
          stat_recorded_ms = ${Tn("stat_recorded_ms")}
      

SELECT rel_path, base_etag, requested_at_ms, mutation_id FROM pending_deletes ORDER BY rel_path ASC

SELECT rel_path FROM pending_deletes WHERE rel_path = ?

SELECT 1 AS ok FROM pending_deletes LIMIT 1

SELECT 1 AS ok FROM pending_deletes
         WHERE rel_path = ? OR (rel_path >= ? AND rel_path < ?)
         LIMIT 1

        INSERT INTO pending_deletes (
          rel_path,
          base_etag,
          requested_at_ms,
          mutation_id
        ) VALUES (?, ?, ?, ?)
        ON CONFLICT(rel_path) DO UPDATE SET
          base_etag = excluded.base_etag,
          requested_at_ms = excluded.requested_at_ms,
          mutation_id = excluded.mutation_id
      

DELETE FROM pending_deletes WHERE rel_path = ?

SELECT rel_path, requested_at_ms FROM pending_rmdirs ORDER BY (LENGTH(rel_path) - LENGTH(REPLACE(rel_path, '/', ''))) DESC, rel_path ASC