bundle

type Action string

type CWDInfo struct {
	// Path is the first-seen original spelling of the cwd (for display).
	Path string
	// Count is how many sessions recorded this cwd.
	Count int
	// ExistsLocal reports whether the directory exists on this machine. A
	// session whose cwd does not exist locally is hidden in Codex's project
	// sidebar until the folder is created or the cwd is remapped on import.
	ExistsLocal bool
}

type CWDMapping struct {
	Old string
	New string
}

type CWDSummary struct {
	// Dirs are the distinct non-empty recorded cwds, sorted by path.
	Dirs []CWDInfo
	// UnknownCWD counts sessions with no recorded cwd (e.g. compressed
	// sessions, whose cwd is unknown in v0.1).
	UnknownCWD int
	// MissingCount is how many entries in Dirs do not exist locally.
	MissingCount int
}

type Checksums map[string]string

type ExportOptions struct {
	// Tool selects which agent's sessions to export ("" / agent.Codex scans the
	// Codex home; agent.Claude scans ClaudeHome). The chosen tool is recorded in
	// the manifest so import knows how to place the files back.
	Tool agent.Kind
	// ClaudeHome is the resolved Claude Code home, used only when Tool is
	// agent.Claude. (The Codex home is passed to Export directly.)
	ClaudeHome claudehome.Home
	// ProjectPath, when non-empty, restricts the export to sessions whose
	// SessionMeta cwd matches this (already absolute) path. Leave empty to
	// export every session regardless of cwd (the `--all` behavior).
	ProjectPath string
	// OutputPath is the .codexbundle file to write.
	OutputPath string
	// IncludeArchived also considers archived sessions.
	IncludeArchived bool
	// Since, when non-zero, restricts the export to sessions whose file
	// modification time is at or after this instant.
	Since time.Time
	// SessionID, when non-empty, exports exactly the single session whose
	// thread id equals (or uniquely begins with) this value, regardless of
	// cwd. It is mutually exclusive with project/all filtering.
	SessionID string
	// OnlyThreadIDs, when non-empty, selects exactly the sessions whose thread id
	// is in this set (exact match), bypassing project/all/since/single selection.
	// It is used by LAN sync to bundle precisely the sessions a peer is missing.
	OnlyThreadIDs []string
	// Match, when non-empty, additionally keeps only sessions whose conversation
	// text matches this query (composes with the project/all/since filters). Regex
	// and case-sensitivity follow the two flags below.
	Match              string
	MatchRegex         bool
	MatchCaseSensitive bool
	// WithGit forces capture of the project's git metadata (remote, branch,
	// commit, dirty/unpushed) into the manifest even when ProjectPath is empty
	// (e.g. with --all or --session). When ProjectPath is set, git metadata is
	// always captured regardless of this flag.
	WithGit bool
	// StripImages replaces inline base64 image payloads in each session with a
	// short placeholder before adding it to the bundle. It is lossy (the picture
	// bytes are dropped) and opt-in, used to shrink image-heavy bundles. The
	// conversation text is preserved; compressed .jsonl.zst sessions are stripped
	// too when the zstd tool is available (otherwise copied as-is with a warning).
	StripImages bool
	// Redact replaces likely secrets (API keys, tokens, private keys) in each
	// session with typed placeholders before bundling. Lossy and opt-in, for
	// sharing/syncing a session without leaking credentials.
	Redact bool
}

type ExportResult struct {
	BundlePath        string
	Manifest          Manifest
	IncludedCount     int
	TotalScanned      int
	CompressedSkipped int   // compressed sessions skipped by cwd filter (cwd unknown)
	ImagesStripped    int   // images replaced when StripImages is set
	BytesSaved        int64 // bundle bytes saved by stripping (original minus stored)
	SecretsRedacted   int   // secrets replaced when Redact is set
	Warnings          []string
}

type ImportItem struct {
	BundlePath  string
	DestPath    string
	Action      Action
	OriginalCWD string
	CWDMismatch bool
	// Mapped reports whether --map-cwd rewrote this session's cwd.
	Mapped bool
	// Copied reports whether this entry was imported as a brand-new session
	// (ActionImportCopy, --import-as-copy) with NewThreadID as its fresh id.
	Copied bool
	// NewThreadID is the freshly assigned session id when Copied is true.
	NewThreadID string
	// BackupPath, when non-empty, is where the pre-existing local file was
	// backed up before being replaced (ActionReplace, --replace-with-backup).
	BackupPath string
	// LinesAdded is the number of new lines a --merge update appended on top of
	// the existing local file (ActionUpdate). It is an approximate, line-based
	// count for reporting only.
	LinesAdded int
	// contains filtered or unexported fields
}

type ImportOptions struct {
	BundlePath string
	DryRun     bool
	// ProjectPath, when non-empty, enables per-session cwd-mismatch checks
	// against this (already absolute) path.
	ProjectPath string
	// MapCWD, when set, rewrites matching sessions' recorded cwd on import.
	// Only plain .jsonl files are rewritten; .jsonl.zst files that match a
	// mapping are copied byte-for-byte and reported as unmappable.
	MapCWD []CWDMapping
	// MapCWDHere is the convenience form of MapCWD for the common "put these
	// sessions under the project I'm in right now" case: it maps the bundle's
	// single recorded project cwd to HereDir without the caller having to look up
	// the old path. It requires the bundle to contain exactly one distinct source
	// cwd; a bundle spanning multiple projects is ambiguous and rejected (use
	// MapCWD explicitly). Mutually exclusive with MapCWD.
	MapCWDHere bool
	// HereDir is the absolute destination path for MapCWDHere (the caller's
	// current working directory). Ignored unless MapCWDHere is set.
	HereDir string
	// ReplaceWithBackup turns conflicts (a local file with different content
	// for the same session) into a replace: the local file is backed up next
	// to itself and then overwritten with the bundle's version. Without it,
	// conflicts are reported and skipped (the default, never-overwrite behavior).
	ReplaceWithBackup bool
	// SessionIDs, when non-empty, restricts the import to the bundle sessions
	// whose thread id equals (or uniquely begins with) one of these values; every
	// other session in the bundle is skipped (ActionSkipDeselected). An id that
	// matches no session in the bundle is an error (nothing is written).
	SessionIDs []string
	// ImportAsCopy turns conflicts into a brand-new session: the bundle's
	// version is assigned a fresh session id and written under a new rollout
	// filename, so it coexists with the diverged local session rather than being
	// skipped or replacing it. Only plain .jsonl files can be copied; a
	// compressed (.jsonl.zst) conflict, or one without a session_meta id, stays a
	// skipped conflict. Mutually exclusive with ReplaceWithBackup at the CLI.
	ImportAsCopy bool
	// Merge enables append-only incremental sync. Session files are append-only
	// logs, so when a session that already exists locally grew on the other
	// device, the bundle's copy is a byte-prefix superset of the local file.
	// With Merge set, such a "grown" session is updated in place (ActionUpdate):
	// the longer bundle version is written, which appends the new lines without
	// losing anything. When the local file is already a superset of the bundle's
	// (the local copy is ahead), the session is left untouched (ActionSkipAhead).
	// Sessions that genuinely diverged (neither side is a prefix of the other)
	// remain conflicts, handled by ReplaceWithBackup/ImportAsCopy or skipped.
	// Merge composes with those two flags: it resolves clean growth first and
	// hands true divergence to them.
	Merge bool
}

type ImportResult struct {
	Manifest         Manifest
	Items            []ImportItem
	Imported         int
	SkippedIdentical int
	Conflicts        int
	SkippedOther     int
	// SkippedDeselected counts bundle sessions excluded by a --session filter.
	SkippedDeselected int
	CWDMismatchCount  int
	// Replaced counts conflicting sessions that were overwritten after the local
	// file was backed up (--replace-with-backup).
	Replaced int
	// Updated counts sessions that grew on the other device and were extended in
	// place by --merge (ActionUpdate). LinesAdded is the total number of lines
	// those updates appended.
	Updated    int
	LinesAdded int
	// AlreadyAhead counts sessions left untouched by --merge because the local
	// copy already contained everything in the bundle (and possibly more).
	AlreadyAhead int
	// ImportedCopies counts conflicting sessions imported as brand-new sessions
	// (--import-as-copy).
	ImportedCopies int
	// Mapped counts imported sessions whose cwd was rewritten by --map-cwd.
	Mapped int
	// MappedCompressedSkipped counts compressed sessions that matched a
	// mapping but could not be rewritten in v0.1 (copied byte-for-byte).
	MappedCompressedSkipped int
	ProjectProvided         bool
	DryRun                  bool
	Warnings                []string
}

type InspectResult struct {
	Manifest  Manifest
	Checksums Checksums
	Entries   []string
}

type Manifest struct {
	FormatVersion string `json:"format_version"`
	// Tool records which coding agent the sessions came from ("codex" or
	// "claude"). It is omitted for legacy Codex bundles, which are treated as
	// "codex" on read, so older bundles remain importable unchanged.
	Tool              string            `json:"tool,omitempty"`
	CreatedAt         string            `json:"created_at"`
	CreatedByDevice   string            `json:"created_by_device,omitempty"`
	SourceOS          string            `json:"source_os"`
	SourceCodexHome   string            `json:"source_codex_home"`
	SourceProjectPath string            `json:"source_project_path,omitempty"`
	Git               *git.Info         `json:"git,omitempty"`
	CodexVersion      string            `json:"codex_version,omitempty"`
	Sessions          []ManifestSession `json:"sessions"`
}

type ManifestSession struct {
	ThreadID         string `json:"thread_id,omitempty"`
	OriginalPath     string `json:"original_path"`
	BundlePath       string `json:"bundle_path"`
	OriginalCWD      string `json:"original_cwd,omitempty"`
	Preview          string `json:"preview,omitempty"`
	FirstUserMessage string `json:"first_user_message,omitempty"`
	CreatedAt        string `json:"created_at,omitempty"`
	UpdatedAt        string `json:"updated_at,omitempty"`
	Source           string `json:"source,omitempty"`
	ModelProvider    string `json:"model_provider,omitempty"`
	GitBranch        string `json:"git_branch,omitempty"`
	GitSHA           string `json:"git_sha,omitempty"`
	Archived         bool   `json:"archived"`
	Compressed       bool   `json:"compressed"`
	SizeBytes        int64  `json:"size_bytes"`
	SHA256           string `json:"sha256"`
}

type SecretScanResult struct {
	SessionsWithSecrets int // number of session entries containing >=1 finding
	TotalFindings       int // total secret findings across all sessions
}

type TranslateItem struct {
	BundlePath string
	DestPath   string
	SessionID  string // id assigned in the target agent
	Turns      int
	Action     string // "translate" | "skip-existing" | "skip"
	Reason     string // why it was skipped, when Action == "skip"
}

type TranslateOptions struct {
	BundlePath string
	TargetTool agent.Kind
	DryRun     bool
}

type TranslateResult struct {
	SourceTool      agent.Kind
	TargetTool      agent.Kind
	Translated      int
	SkippedExisting int
	Skipped         int
	Items           []TranslateItem
	Warnings        []string
	DryRun          bool
}