pitboard-core 0.14.0

The engine behind Pitboard: switches Claude Code, Codex and Claude Desktop between accounts by parking and restoring their logins. Its API serves Pitboard's own front ends.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

pub(crate) mod assumptions;
mod jar;
mod layout;
pub(crate) mod paths;
mod running;
mod settings;

use crate::context::Context;
use crate::holder::{AppId, Holder, Location, Noun, Remedy};
use crate::host::Listed;
use crate::provider::folder::{AppSettings, Class, Folder, Keys, SignedIn, Unfit, Unread};
use crate::provider::{ProviderError, ProviderId};
use crate::service::Permit;
use serde_json::value::RawValue;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};

pub(crate) const BUNDLE_ID: &str = "com.anthropic.claudefordesktop";

pub(crate) const HOLDER: Holder = Holder {
    kind: "claude_desktop",
    noun: Noun::One("Claude"),
    location: Location::Anywhere,
    remedy: Remedy::ReopenApp {
        app: AppId::MacBundle(BUNDLE_ID),
        name: "Claude",
    },
};

// The jar first: it holds the session.
const ITEMS: &[&str] = &[
    "Cookies",
    "Cookies-journal",
    "Local Storage",
    "Session Storage",
    "IndexedDB/https_claude.ai_0.indexeddb.leveldb",
    "IndexedDB/https_claude.ai_0.indexeddb.blob",
    "WebStorage",
    "File System",
];

const NAMING_KEY: &str = "lastKnownAccountUuid";
const KEYS: &[&str] = &["oauth:tokenCache", "oauth:tokenCacheV2", NAMING_KEY];

#[derive(Debug)]
pub(crate) struct Desktop;

impl Folder for Desktop {
    fn id(&self) -> ProviderId {
        ProviderId::Desktop
    }

    fn root(&self, ctx: &Context) -> Result<PathBuf, ProviderError> {
        paths::root(ctx)
    }

    fn refuses(&self, root: &Path) -> Option<Unfit> {
        paths::refuses(root)
    }

    fn items(&self) -> &'static [&'static str] {
        ITEMS
    }

    fn keys(&self) -> &'static [&'static str] {
        KEYS
    }

    fn naming_key(&self) -> &'static str {
        NAMING_KEY
    }

    fn classify(&self, name: &OsStr) -> Class {
        layout::classify(name)
    }

    fn settings(&self, root: &Path) -> Result<AppSettings, Unread> {
        settings::read(root, NAMING_KEY)
    }

    fn write_settings(
        &self,
        permit: Permit,
        root: &Path,
        read: &AppSettings,
        keys: &Keys,
    ) -> Result<(), Unread> {
        settings::write(permit, root, read, &read.with(self, keys))
    }

    fn session(&self, ctx: &Context, jar: &Path) -> Result<Option<SignedIn>, Unread> {
        jar::session(ctx, jar)
    }

    fn emptied(&self, key: &str, value: &RawValue) -> bool {
        jar::emptied(key, value)
    }

    fn is_the_app(&self, ctx: &Context, root: &Path, one: &Listed, all: &[Listed]) -> bool {
        running::is_the_app(ctx, root, one, all)
    }

    fn holder(&self) -> &'static Holder {
        &HOLDER
    }

    fn app_name(&self) -> &'static str {
        "Claude"
    }
}