claude-code-toolkit 0.3.1

Claude Code management tool for credential sync, session monitoring, and GitHub integration
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use serde::{ Deserialize, Serialize };

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClaudeCredentials {
  #[serde(rename = "claudeAiOauth")]
  pub claude_ai_oauth: ClaudeOAuth,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClaudeOAuth {
  #[serde(rename = "accessToken")]
  pub access_token: String,
  #[serde(rename = "refreshToken")]
  pub refresh_token: String,
  #[serde(rename = "expiresAt")]
  pub expires_at: i64,
  pub scopes: Vec<String>,
  #[serde(rename = "subscriptionType")]
  pub subscription_type: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
  pub daemon: DaemonConfig,
  pub github: GitHubConfig,
  pub notifications: NotificationConfig,
  pub credentials: CredentialsConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DaemonConfig {
  pub log_level: String,
  pub sync_delay_after_expiry: u64, // seconds
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GitHubConfig {
  pub organizations: Vec<GitHubOrganization>,
  pub repositories: Vec<GitHubRepository>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GitHubOrganization {
  pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GitHubRepository {
  pub repo: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationConfig {
  pub session_warnings: Vec<u64>, // minutes before expiry
  pub sync_failures: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CredentialsConfig {
  /// Path to credential file (supports ~ for home directory)
  pub file_path: String,

  /// JSON path to the credential object within the file
  /// For Claude Code: "claudeAiOauth"
  pub json_path: String,

  /// Field mappings: credential_field -> github_secret_name
  pub field_mappings: std::collections::HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SyncState {
  pub last_sync: i64,
  pub last_token: String,
  pub targets: Vec<TargetStatus>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TargetStatus {
  pub target_type: TargetType,
  pub name: String,
  pub last_sync_time: i64,
  pub last_sync_status: SyncStatus,
  pub last_error: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TargetType {
  Organization,
  Repository,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SyncStatus {
  Success,
  Failure,
}

#[derive(Debug, Clone)]
pub struct SessionInfo {
  pub expires_at: i64,
  pub time_remaining: i64,
  pub is_expired: bool,
  pub subscription_type: String,
}

#[derive(Debug, Clone)]
pub struct GitHubTarget {
  pub target_type: TargetType,
  pub name: String,
}

impl Default for Config {
  fn default() -> Self {
    Self {
      daemon: DaemonConfig {
        log_level: "info".to_string(),
        sync_delay_after_expiry: 60,
      },
      github: GitHubConfig {
        organizations: vec![],
        repositories: vec![],
      },
      notifications: NotificationConfig {
        session_warnings: vec![30, 15, 5],
        sync_failures: true,
      },
      credentials: CredentialsConfig {
        file_path: "~/.claude/.credentials.json".to_string(),
        json_path: "claudeAiOauth".to_string(),
        field_mappings: std::collections::HashMap::new(),
      },
    }
  }
}

impl std::fmt::Display for TargetType {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    match self {
      TargetType::Organization => write!(f, "organization"),
      TargetType::Repository => write!(f, "repository"),
    }
  }
}

impl std::fmt::Display for SyncStatus {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    match self {
      SyncStatus::Success => write!(f, "success"),
      SyncStatus::Failure => write!(f, "failure"),
    }
  }
}