brain-memory 0.1.0-beta.11 → 0.1.0-beta.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,149 @@
1
+ #!/usr/bin/env node
2
+
3
+ /**
4
+ * brain-cloud — CLI for Brain Cloud sync
5
+ *
6
+ * Usage:
7
+ * brain-cloud login [--api-url URL] Authenticate via device code flow
8
+ * brain-cloud logout Clear stored credentials
9
+ * brain-cloud push Upload ~/.brain/ to the cloud
10
+ * brain-cloud pull Download from the cloud to ~/.brain/
11
+ * brain-cloud status Show connection and sync status
12
+ */
13
+
14
+ const path = require('path');
15
+ const os = require('os');
16
+ const cloud = require('../src/cloud-sync');
17
+
18
+ const BRAIN_DIR = path.join(os.homedir(), '.brain');
19
+
20
+ async function main() {
21
+ const args = process.argv.slice(2);
22
+ const command = args[0];
23
+
24
+ if (!command || command === '--help' || command === '-h') {
25
+ console.log(`
26
+ brain-cloud — Brain Cloud sync CLI
27
+
28
+ Commands:
29
+ login [--api-url URL] Authenticate via device code flow
30
+ logout Clear stored credentials
31
+ push Upload ~/.brain/ to the cloud
32
+ pull Download from the cloud to ~/.brain/
33
+ status Show connection and sync status
34
+ `.trim());
35
+ process.exit(0);
36
+ }
37
+
38
+ switch (command) {
39
+ case 'login':
40
+ await cmdLogin(args);
41
+ break;
42
+ case 'logout':
43
+ cmdLogout();
44
+ break;
45
+ case 'push':
46
+ await cmdPush();
47
+ break;
48
+ case 'pull':
49
+ await cmdPull();
50
+ break;
51
+ case 'status':
52
+ await cmdStatus();
53
+ break;
54
+ default:
55
+ console.error(`Unknown command: ${command}`);
56
+ process.exit(1);
57
+ }
58
+ }
59
+
60
+ async function cmdLogin(args) {
61
+ let apiUrl;
62
+ const urlIdx = args.indexOf('--api-url');
63
+ if (urlIdx !== -1 && args[urlIdx + 1]) {
64
+ apiUrl = args[urlIdx + 1];
65
+ }
66
+
67
+ console.log('Requesting device code...');
68
+ const loginInfo = await cloud.login(BRAIN_DIR, apiUrl);
69
+
70
+ console.log();
71
+ console.log(' Open this URL in your browser to log in:');
72
+ console.log();
73
+ console.log(` ${loginInfo.verify_url}`);
74
+ console.log();
75
+ console.log(` Your code: ${loginInfo.user_code}`);
76
+ console.log();
77
+ console.log(` Waiting for approval (expires in ${Math.floor(loginInfo.expires_in / 60)} min)...`);
78
+
79
+ await loginInfo.waitForApproval();
80
+
81
+ const config = cloud.readConfig(BRAIN_DIR);
82
+ console.log();
83
+ console.log(`✓ Logged in as ${config.user_email || 'unknown'}`);
84
+ if (config.brain_id) {
85
+ console.log(` Brain ID: ${config.brain_id}`);
86
+ }
87
+ console.log(` API: ${config.api_url}`);
88
+ }
89
+
90
+ function cmdLogout() {
91
+ cloud.logout(BRAIN_DIR);
92
+ console.log('✓ Logged out. Credentials cleared.');
93
+ }
94
+
95
+ async function cmdPush() {
96
+ console.log('Packing ~/.brain/ ...');
97
+ const result = await cloud.push(BRAIN_DIR);
98
+ console.log();
99
+ console.log('✓ Push complete!');
100
+ console.log(` Size: ${formatBytes(result.size_bytes)}`);
101
+ console.log(` Files: ${result.file_count}`);
102
+ console.log(` Checksum: ${result.checksum}`);
103
+ }
104
+
105
+ async function cmdPull() {
106
+ console.log('Downloading from cloud...');
107
+ const result = await cloud.pull(BRAIN_DIR);
108
+ console.log();
109
+ console.log('✓ Pull complete!');
110
+ console.log(` Size: ${formatBytes(result.size_bytes)}`);
111
+ if (result.checksum) {
112
+ console.log(` Checksum: ${result.checksum}`);
113
+ }
114
+ }
115
+
116
+ async function cmdStatus() {
117
+ const s = await cloud.status(BRAIN_DIR);
118
+
119
+ if (!s.connected) {
120
+ console.log('☁️ Not connected to Brain Cloud');
121
+ console.log(' Run: brain-cloud login');
122
+ return;
123
+ }
124
+
125
+ console.log('☁️ Brain Cloud Status');
126
+ console.log('─────────────────────────');
127
+ console.log(` API: ${s.api_url}`);
128
+ console.log(` User: ${s.user_email || 'unknown'}`);
129
+ console.log(` Brain ID: ${s.brain_id || 'none'}`);
130
+ if (s.brain_name) console.log(` Brain Name: ${s.brain_name}`);
131
+ if (s.brain_size !== null) console.log(` Cloud Size: ${formatBytes(s.brain_size)}`);
132
+ if (s.brain_files !== null) console.log(` Cloud Files: ${s.brain_files}`);
133
+ console.log(` Last Push: ${s.last_push || 'never'}`);
134
+ console.log(` Last Pull: ${s.last_pull || 'never'}`);
135
+ console.log(` Last Synced: ${s.last_synced || 'never'}`);
136
+ console.log(` Connected: ${s.connected_at || 'unknown'}`);
137
+ }
138
+
139
+ function formatBytes(bytes) {
140
+ if (bytes === 0 || bytes === null || bytes === undefined) return '0 B';
141
+ const units = ['B', 'KB', 'MB', 'GB'];
142
+ const i = Math.floor(Math.log(bytes) / Math.log(1024));
143
+ return `${(bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
144
+ }
145
+
146
+ main().catch((err) => {
147
+ console.error(`Error: ${err.message}`);
148
+ process.exit(1);
149
+ });
@@ -11,6 +11,15 @@ You are managing synchronization for the Brain Memory system. This enables manua
11
11
  ## Subcommands
12
12
 
13
13
  Parse the user's input to determine the subcommand:
14
+
15
+ **Cloud Sync (Brain Cloud API):**
16
+ - `cloud login [--api-url URL]` → Authenticate via device code flow
17
+ - `cloud push` → Upload ~/.brain/ to Brain Cloud
18
+ - `cloud pull` → Download from Brain Cloud to ~/.brain/
19
+ - `cloud status` → Show cloud connection info
20
+ - `cloud logout` → Clear stored credentials
21
+
22
+ **Git Sync (any Git remote):**
14
23
  - `setup <url>` → Configure a Git remote for sync
15
24
  - `push` → Commit and push local changes to remote
16
25
  - `pull` → Fetch and merge remote changes to local
@@ -23,6 +32,138 @@ If no subcommand is given, show available subcommands.
23
32
 
24
33
  ---
25
34
 
35
+ ## `/brain:sync cloud login [--api-url URL]`
36
+
37
+ ### Steps
38
+
39
+ 1. **Check if already logged in:**
40
+ - Read `~/.brain/.cloud/config.json` via `readConfig()` from `src/cloud-sync.js`.
41
+ - If already connected, show current user and ask if they want to re-authenticate.
42
+
43
+ 2. **Start device code flow:**
44
+ - Run `brain-cloud login` (or call `login()` from `src/cloud-sync.js`).
45
+ - This calls `POST /auth/device/request` and returns a user code + verification URL.
46
+
47
+ 3. **Display instructions to user:**
48
+ ```
49
+ 🔐 Brain Cloud Login
50
+
51
+ Open this URL in your browser:
52
+ <verify_url>
53
+
54
+ Your code: <user_code>
55
+
56
+ Waiting for approval...
57
+ ```
58
+
59
+ 4. **Wait for approval:**
60
+ - The CLI polls `POST /auth/device/poll` every 5 seconds.
61
+ - Once approved, tokens are saved to `~/.brain/.cloud/config.json`.
62
+
63
+ 5. **Show result:**
64
+ ```
65
+ ✓ Logged in as <email>
66
+ Brain ID: <brain_id>
67
+ API: <api_url>
68
+ ```
69
+
70
+ ---
71
+
72
+ ## `/brain:sync cloud push`
73
+
74
+ ### Steps
75
+
76
+ 1. **Check logged in.** If not, suggest `cloud login`.
77
+
78
+ 2. **Preview:**
79
+ - Count local files in `~/.brain/` (excluding `.sync`, `.cloud`, `_archived`).
80
+ - Show estimated size.
81
+ ```
82
+ 📤 Cloud Push Preview:
83
+ Local files: <count>
84
+ Destination: <api_url>
85
+ ```
86
+
87
+ 3. **Ask for confirmation.**
88
+
89
+ 4. **Execute push:**
90
+ - Run `brain-cloud push` (or call `push()` from `src/cloud-sync.js`).
91
+ - This packs `~/.brain/` into a tar.gz and uploads via `PUT /api/brains/{id}/sync`.
92
+ - Show result:
93
+ ```
94
+ ✓ Push complete!
95
+ Size: <size>
96
+ Files: <count>
97
+ Checksum: <checksum>
98
+ ```
99
+
100
+ ---
101
+
102
+ ## `/brain:sync cloud pull`
103
+
104
+ ### Steps
105
+
106
+ 1. **Check logged in.**
107
+
108
+ 2. **Warn about overwrite:**
109
+ ```
110
+ 📥 Cloud Pull Preview:
111
+ Source: <api_url>
112
+ ⚠️ This will overwrite local files with the cloud version.
113
+ ```
114
+
115
+ 3. **Ask for confirmation.**
116
+
117
+ 4. **Execute pull:**
118
+ - Run `brain-cloud pull` (or call `pull()` from `src/cloud-sync.js`).
119
+ - Downloads tar.gz from `GET /api/brains/{id}/sync` and extracts to `~/.brain/`.
120
+ - Show result:
121
+ ```
122
+ ✓ Pull complete!
123
+ Size: <size>
124
+ ```
125
+
126
+ 5. **Rebuild index:**
127
+ - After pull, run the index manager to rebuild `~/.brain/index.json`.
128
+
129
+ ---
130
+
131
+ ## `/brain:sync cloud status`
132
+
133
+ ### Steps
134
+
135
+ 1. **Read cloud config** using `readConfig()` from `src/cloud-sync.js`.
136
+
137
+ 2. **Fetch live status** (if connected) by calling `status()` from `src/cloud-sync.js`.
138
+
139
+ 3. **Display dashboard:**
140
+ ```
141
+ ☁️ Brain Cloud Status
142
+ ─────────────────────────
143
+ API: <api_url or "not connected">
144
+ User: <email>
145
+ Brain ID: <brain_id>
146
+ Cloud Size: <size>
147
+ Cloud Files: <count>
148
+ Last Push: <timestamp or "never">
149
+ Last Pull: <timestamp or "never">
150
+ Last Synced: <timestamp or "never">
151
+ Connected: <timestamp>
152
+ ```
153
+
154
+ ---
155
+
156
+ ## `/brain:sync cloud logout`
157
+
158
+ ### Steps
159
+
160
+ 1. **Show current connection** (API URL, email).
161
+ 2. **Ask for confirmation:** "This will clear your stored credentials. Cloud data will NOT be deleted."
162
+ 3. **Remove `~/.brain/.cloud/` directory.**
163
+ 4. **Confirm:** "✓ Logged out. Cloud data is untouched."
164
+
165
+ ---
166
+
26
167
  ## `/brain:sync setup <url>`
27
168
 
28
169
  ### Steps
@@ -214,9 +355,13 @@ If no subcommand is given, show available subcommands.
214
355
 
215
356
  ## Key Implementation Notes
216
357
 
358
+ - **Cloud sync engine**: `src/cloud-sync.js` — API client for Brain Cloud
359
+ - **Cloud CLI**: `bin/cloud-sync.js` — installed as `brain-cloud` command
360
+ - **Cloud config**: stored in `~/.brain/.cloud/config.json` (tokens, brain ID, API URL)
361
+ - **Cloud protocol**: tar.gz archives uploaded/downloaded via REST API
217
362
  - Git sync engine: `src/git-sync.js`
218
363
  - Export/import: `src/export-import.js`
219
364
  - Crypto utilities: `src/crypto.js`
220
- - Sync config stored in `~/.brain/.sync/config.json` (local only)
365
+ - Git sync config stored in `~/.brain/.sync/config.json` (local only)
221
366
  - Hidden git repo at `~/.brain/.sync/repo/` — never interferes with the project's own git
222
- - All git operations use `execFileSync` — no npm dependencies
367
+ - All operations use Node.js built-ins only — no npm runtime dependencies
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "brain-memory",
3
- "version": "0.1.0-beta.11",
3
+ "version": "0.1.0-beta.12",
4
4
  "description": "A brain-inspired hierarchical memory system for AI coding agents. Deep nested file structure that mimics human memory with time-decay and strength-based recall.",
5
5
  "keywords": [
6
6
  "claude-code",
@@ -26,7 +26,8 @@
26
26
  "bin": {
27
27
  "brain-memory": "bin/install.js",
28
28
  "brain-recall": "bin/recall.js",
29
- "brain-reinforce": "bin/reinforce.js"
29
+ "brain-reinforce": "bin/reinforce.js",
30
+ "brain-cloud": "bin/cloud-sync.js"
30
31
  },
31
32
  "files": [
32
33
  "assets/",
@@ -0,0 +1,524 @@
1
+ /**
2
+ * Brain Memory — Cloud Sync Engine
3
+ *
4
+ * Push/pull ~/.brain/ memories via the Brain Cloud API (api.brainmemory.work).
5
+ * Uses the device code OAuth flow for CLI authentication.
6
+ *
7
+ * Zero external dependencies — uses Node.js built-in https, fs, child_process.
8
+ */
9
+
10
+ const { execFileSync } = require('child_process');
11
+ const fs = require('fs');
12
+ const path = require('path');
13
+ const os = require('os');
14
+ const https = require('https');
15
+ const http = require('http');
16
+
17
+ const CLOUD_DIR = '.cloud';
18
+ const CONFIG_FILE = 'config.json';
19
+ const DEFAULT_API_URL = 'https://api.brainmemory.work';
20
+
21
+ // Files/dirs inside ~/.brain/ that should NOT be synced
22
+ const TAR_EXCLUDES = ['.sync', '.cloud', '.DS_Store', '_archived'];
23
+
24
+ // ---------------------------------------------------------------------------
25
+ // HTTP helpers (zero-dependency, works on Node >= 18)
26
+ // ---------------------------------------------------------------------------
27
+
28
+ /**
29
+ * Make an HTTP(S) request. Returns { status, headers, body }.
30
+ *
31
+ * @param {string} url
32
+ * @param {Object} [opts]
33
+ * @param {string} [opts.method='GET']
34
+ * @param {Object} [opts.headers]
35
+ * @param {Buffer|string} [opts.body]
36
+ * @returns {Promise<{status: number, headers: Object, body: string}>}
37
+ */
38
+ function request(url, opts = {}, _redirectCount = 0) {
39
+ return new Promise((resolve, reject) => {
40
+ if (_redirectCount > 5) return reject(new Error('Too many redirects'));
41
+
42
+ const parsed = new URL(url);
43
+ const mod = parsed.protocol === 'https:' ? https : http;
44
+ const reqOpts = {
45
+ method: opts.method || 'GET',
46
+ hostname: parsed.hostname,
47
+ port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
48
+ path: parsed.pathname + parsed.search,
49
+ headers: opts.headers || {},
50
+ };
51
+
52
+ const req = mod.request(reqOpts, (res) => {
53
+ // Follow redirects
54
+ if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
55
+ const redirectUrl = new URL(res.headers.location, url).href;
56
+ // For 307/308, preserve method and body; for 301/302, switch to GET
57
+ const newOpts = [307, 308].includes(res.statusCode)
58
+ ? opts
59
+ : { ...opts, method: 'GET', body: undefined };
60
+ res.resume(); // drain the response
61
+ return resolve(request(redirectUrl, newOpts, _redirectCount + 1));
62
+ }
63
+
64
+ const chunks = [];
65
+ res.on('data', (chunk) => chunks.push(chunk));
66
+ res.on('end', () => {
67
+ resolve({
68
+ status: res.statusCode,
69
+ headers: res.headers,
70
+ body: Buffer.concat(chunks).toString('utf8'),
71
+ });
72
+ });
73
+ });
74
+
75
+ req.on('error', reject);
76
+ req.setTimeout(60000, () => { req.destroy(new Error('Request timed out')); });
77
+
78
+ if (opts.body) req.write(opts.body);
79
+ req.end();
80
+ });
81
+ }
82
+
83
+ /**
84
+ * JSON POST/PUT helper.
85
+ */
86
+ async function jsonRequest(url, method, data, token) {
87
+ const headers = { 'Content-Type': 'application/json' };
88
+ if (token) headers['Authorization'] = `Bearer ${token}`;
89
+ const body = data != null ? JSON.stringify(data) : undefined;
90
+ if (body) headers['Content-Length'] = Buffer.byteLength(body).toString();
91
+ const res = await request(url, { method, headers, body });
92
+ try {
93
+ return { status: res.status, data: JSON.parse(res.body) };
94
+ } catch {
95
+ throw new Error(`Non-JSON response (${res.status}) from ${method} ${url}: ${res.body.slice(0, 200)}`);
96
+ }
97
+ }
98
+
99
+ /**
100
+ * Upload a file as multipart/form-data.
101
+ */
102
+ async function uploadFile(url, filePath, token) {
103
+ const boundary = '----BrainCloudUpload' + Date.now();
104
+ const fileContent = fs.readFileSync(filePath);
105
+ const header = Buffer.from(
106
+ `--${boundary}\r\n` +
107
+ `Content-Disposition: form-data; name="brain"; filename="brain.tar.gz"\r\n` +
108
+ `Content-Type: application/gzip\r\n\r\n`
109
+ );
110
+ const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
111
+ const body = Buffer.concat([header, fileContent, footer]);
112
+
113
+ return request(url, {
114
+ method: 'PUT',
115
+ headers: {
116
+ 'Content-Type': `multipart/form-data; boundary=${boundary}`,
117
+ 'Content-Length': body.length.toString(),
118
+ 'Authorization': `Bearer ${token}`,
119
+ },
120
+ body,
121
+ });
122
+ }
123
+
124
+ /**
125
+ * Download a file from URL, save to disk.
126
+ */
127
+ function downloadFile(url, destPath, token, _redirectCount = 0) {
128
+ return new Promise((resolve, reject) => {
129
+ if (_redirectCount > 5) return reject(new Error('Too many redirects'));
130
+
131
+ const parsed = new URL(url);
132
+ const mod = parsed.protocol === 'https:' ? https : http;
133
+ const reqOpts = {
134
+ method: 'GET',
135
+ hostname: parsed.hostname,
136
+ port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
137
+ path: parsed.pathname + parsed.search,
138
+ headers: { 'Authorization': `Bearer ${token}` },
139
+ };
140
+
141
+ const req = mod.request(reqOpts, (res) => {
142
+ // Follow redirects
143
+ if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
144
+ const redirectUrl = new URL(res.headers.location, url).href;
145
+ res.resume();
146
+ return resolve(downloadFile(redirectUrl, destPath, token, _redirectCount + 1));
147
+ }
148
+
149
+ if (res.statusCode !== 200) {
150
+ const chunks = [];
151
+ res.on('data', (c) => chunks.push(c));
152
+ res.on('end', () => {
153
+ reject(new Error(`Download failed (${res.statusCode}): ${Buffer.concat(chunks).toString()}`));
154
+ });
155
+ return;
156
+ }
157
+
158
+ const ws = fs.createWriteStream(destPath);
159
+ res.pipe(ws);
160
+ ws.on('finish', () => {
161
+ ws.close();
162
+ resolve({ checksum: res.headers['x-checksum'] || null });
163
+ });
164
+ ws.on('error', reject);
165
+ });
166
+
167
+ req.on('error', reject);
168
+ req.setTimeout(300000, () => { req.destroy(new Error('Download timed out')); });
169
+ req.end();
170
+ });
171
+ }
172
+
173
+ // ---------------------------------------------------------------------------
174
+ // Config management — stored at ~/.brain/.cloud/config.json
175
+ // ---------------------------------------------------------------------------
176
+
177
+ function resolvePaths(brainDir) {
178
+ const cloudDir = path.join(brainDir, CLOUD_DIR);
179
+ const configPath = path.join(cloudDir, CONFIG_FILE);
180
+ return { cloudDir, configPath };
181
+ }
182
+
183
+ function readConfig(brainDir) {
184
+ const { configPath } = resolvePaths(brainDir);
185
+ try {
186
+ return JSON.parse(fs.readFileSync(configPath, 'utf8'));
187
+ } catch {
188
+ return null;
189
+ }
190
+ }
191
+
192
+ function writeConfig(brainDir, config) {
193
+ const { cloudDir, configPath } = resolvePaths(brainDir);
194
+ fs.mkdirSync(cloudDir, { recursive: true });
195
+ fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
196
+ }
197
+
198
+ function deleteConfig(brainDir) {
199
+ const { cloudDir } = resolvePaths(brainDir);
200
+ fs.rmSync(cloudDir, { recursive: true, force: true });
201
+ }
202
+
203
+ // ---------------------------------------------------------------------------
204
+ // Token management
205
+ // ---------------------------------------------------------------------------
206
+
207
+ /**
208
+ * Get a valid access token, refreshing if needed.
209
+ *
210
+ * @param {string} brainDir
211
+ * @returns {Promise<string>} access token
212
+ */
213
+ async function getValidToken(brainDir) {
214
+ const config = readConfig(brainDir);
215
+ if (!config) throw new Error('Not logged in. Run cloud login first.');
216
+
217
+ const now = Math.floor(Date.now() / 1000);
218
+
219
+ // Token still valid (with 30s buffer)
220
+ if (config.expires_at && now < config.expires_at - 30) {
221
+ return config.access_token;
222
+ }
223
+
224
+ // Try refresh
225
+ if (!config.refresh_token) {
226
+ throw new Error('Session expired and no refresh token. Run cloud login again.');
227
+ }
228
+
229
+ const res = await jsonRequest(
230
+ `${config.api_url}/auth/refresh`,
231
+ 'POST',
232
+ { refresh_token: config.refresh_token }
233
+ );
234
+
235
+ if (res.status !== 200) {
236
+ throw new Error('Token refresh failed. Run cloud login again.');
237
+ }
238
+
239
+ config.access_token = res.data.access_token;
240
+ config.refresh_token = res.data.refresh_token;
241
+ config.expires_at = res.data.expires_at;
242
+ writeConfig(brainDir, config);
243
+
244
+ return config.access_token;
245
+ }
246
+
247
+ // ---------------------------------------------------------------------------
248
+ // Device code auth flow
249
+ // ---------------------------------------------------------------------------
250
+
251
+ /**
252
+ * Start the device code login flow.
253
+ * Returns the device code info so the caller can display it to the user.
254
+ *
255
+ * @param {string} apiUrl
256
+ * @returns {Promise<{device_code: string, user_code: string, verify_url: string, expires_in: number}>}
257
+ */
258
+ async function requestDeviceCode(apiUrl) {
259
+ const res = await jsonRequest(`${apiUrl}/auth/device/request`, 'POST', {});
260
+ if (res.status !== 200) {
261
+ throw new Error(`Failed to request device code: ${JSON.stringify(res.data)}`);
262
+ }
263
+ return res.data;
264
+ }
265
+
266
+ /**
267
+ * Poll for device code approval.
268
+ *
269
+ * @param {string} apiUrl
270
+ * @param {string} deviceCode
271
+ * @param {number} interval - Poll interval in ms (default 5000)
272
+ * @param {number} timeout - Max wait in ms (default 600000 = 10 min)
273
+ * @returns {Promise<{access_token: string, refresh_token: string, expires_at: number}>}
274
+ */
275
+ async function pollDeviceCode(apiUrl, deviceCode, interval = 5000, timeout = 600000) {
276
+ const deadline = Date.now() + timeout;
277
+
278
+ while (Date.now() < deadline) {
279
+ const res = await jsonRequest(`${apiUrl}/auth/device/poll`, 'POST', { device_code: deviceCode });
280
+
281
+ if (res.status === 200 && res.data.status === 'approved' && res.data.tokens) {
282
+ return res.data.tokens;
283
+ }
284
+
285
+ if (res.status === 404 || (res.data && res.data.error && res.data.error.includes('expired'))) {
286
+ throw new Error('Device code expired. Try again.');
287
+ }
288
+
289
+ // Still pending — wait and retry
290
+ await new Promise((r) => setTimeout(r, interval));
291
+ }
292
+
293
+ throw new Error('Login timed out. Try again.');
294
+ }
295
+
296
+ /**
297
+ * Full login flow: request code, poll, save config.
298
+ *
299
+ * @param {string} brainDir
300
+ * @param {string} [apiUrl]
301
+ * @returns {Promise<{user_code: string, verify_url: string, waitForApproval: () => Promise<void>}>}
302
+ */
303
+ async function login(brainDir, apiUrl) {
304
+ const url = apiUrl || DEFAULT_API_URL;
305
+ const codeInfo = await requestDeviceCode(url);
306
+
307
+ return {
308
+ user_code: codeInfo.user_code,
309
+ verify_url: codeInfo.verify_url,
310
+ expires_in: codeInfo.expires_in,
311
+ waitForApproval: async () => {
312
+ const tokens = await pollDeviceCode(url, codeInfo.device_code);
313
+
314
+ // Fetch user info + default brain
315
+ const meRes = await jsonRequest(`${url}/auth/me`, 'GET', null, tokens.access_token);
316
+ let userEmail = '';
317
+ if (meRes.status === 200 && meRes.data.user) {
318
+ userEmail = meRes.data.user.email;
319
+ }
320
+
321
+ const brainsRes = await jsonRequest(`${url}/api/brains`, 'GET', null, tokens.access_token);
322
+ let brainId = null;
323
+ if (brainsRes.status === 200 && Array.isArray(brainsRes.data) && brainsRes.data.length > 0) {
324
+ brainId = brainsRes.data[0].id;
325
+ }
326
+
327
+ writeConfig(brainDir, {
328
+ api_url: url,
329
+ access_token: tokens.access_token,
330
+ refresh_token: tokens.refresh_token,
331
+ expires_at: tokens.expires_at,
332
+ brain_id: brainId,
333
+ user_email: userEmail,
334
+ connected_at: new Date().toISOString(),
335
+ });
336
+ },
337
+ };
338
+ }
339
+
340
+ /**
341
+ * Logout — clear stored tokens.
342
+ *
343
+ * @param {string} brainDir
344
+ */
345
+ function logout(brainDir) {
346
+ deleteConfig(brainDir);
347
+ }
348
+
349
+ // ---------------------------------------------------------------------------
350
+ // Tar helpers
351
+ // ---------------------------------------------------------------------------
352
+
353
+ function packBrain(brainDir) {
354
+ const tmpFile = path.join(os.tmpdir(), `brain-upload-${Date.now()}.tar.gz`);
355
+ const excludeArgs = TAR_EXCLUDES.flatMap((e) => ['--exclude', e]);
356
+
357
+ execFileSync('tar', ['czf', tmpFile, ...excludeArgs, '-C', brainDir, '.'], {
358
+ stdio: 'pipe',
359
+ timeout: 120000,
360
+ });
361
+
362
+ return tmpFile;
363
+ }
364
+
365
+ function unpackBrain(tarPath, brainDir) {
366
+ // Extract into brain dir, overwriting existing files
367
+ execFileSync('tar', ['xzf', tarPath, '-C', brainDir], {
368
+ stdio: 'pipe',
369
+ timeout: 120000,
370
+ });
371
+ }
372
+
373
+ // ---------------------------------------------------------------------------
374
+ // Push / Pull
375
+ // ---------------------------------------------------------------------------
376
+
377
+ /**
378
+ * Push ~/.brain/ to the cloud.
379
+ *
380
+ * @param {string} brainDir
381
+ * @returns {Promise<{size_bytes: number, file_count: number, checksum: string}>}
382
+ */
383
+ async function push(brainDir) {
384
+ const config = readConfig(brainDir);
385
+ if (!config) throw new Error('Not logged in. Run cloud login first.');
386
+ if (!config.brain_id) throw new Error('No brain linked. Run cloud login again.');
387
+
388
+ const token = await getValidToken(brainDir);
389
+
390
+ // Pack ~/.brain/ into tar.gz
391
+ const tarPath = packBrain(brainDir);
392
+
393
+ try {
394
+ const tarSize = fs.statSync(tarPath).size;
395
+ const url = `${config.api_url}/api/brains/${config.brain_id}/sync`;
396
+
397
+ const res = await uploadFile(url, tarPath, token);
398
+
399
+ if (res.status !== 200) {
400
+ const data = JSON.parse(res.body);
401
+ throw new Error(`Push failed (${res.status}): ${data.error || res.body}`);
402
+ }
403
+
404
+ const result = JSON.parse(res.body);
405
+
406
+ // Update config with last push time
407
+ config.last_push = new Date().toISOString();
408
+ writeConfig(brainDir, config);
409
+
410
+ return { ...result, local_size: tarSize };
411
+ } finally {
412
+ // Clean up temp file
413
+ try { fs.unlinkSync(tarPath); } catch { /* ignore */ }
414
+ }
415
+ }
416
+
417
+ /**
418
+ * Pull from the cloud into ~/.brain/.
419
+ *
420
+ * @param {string} brainDir
421
+ * @returns {Promise<{size_bytes: number, checksum: string|null}>}
422
+ */
423
+ async function pull(brainDir) {
424
+ const config = readConfig(brainDir);
425
+ if (!config) throw new Error('Not logged in. Run cloud login first.');
426
+ if (!config.brain_id) throw new Error('No brain linked. Run cloud login again.');
427
+
428
+ const token = await getValidToken(brainDir);
429
+ const url = `${config.api_url}/api/brains/${config.brain_id}/sync`;
430
+ const tmpFile = path.join(os.tmpdir(), `brain-download-${Date.now()}.tar.gz`);
431
+
432
+ try {
433
+ const { checksum } = await downloadFile(url, tmpFile, token);
434
+ const size = fs.statSync(tmpFile).size;
435
+
436
+ // Extract into ~/.brain/
437
+ unpackBrain(tmpFile, brainDir);
438
+
439
+ // Update config
440
+ config.last_pull = new Date().toISOString();
441
+ writeConfig(brainDir, config);
442
+
443
+ return { size_bytes: size, checksum };
444
+ } finally {
445
+ try { fs.unlinkSync(tmpFile); } catch { /* ignore */ }
446
+ }
447
+ }
448
+
449
+ // ---------------------------------------------------------------------------
450
+ // Status
451
+ // ---------------------------------------------------------------------------
452
+
453
+ /**
454
+ * Get cloud sync status.
455
+ *
456
+ * @param {string} brainDir
457
+ * @returns {Promise<Object>}
458
+ */
459
+ async function status(brainDir) {
460
+ const config = readConfig(brainDir);
461
+ if (!config) {
462
+ return { connected: false };
463
+ }
464
+
465
+ let brain = null;
466
+ let user = null;
467
+
468
+ try {
469
+ const token = await getValidToken(brainDir);
470
+
471
+ const meRes = await jsonRequest(`${config.api_url}/auth/me`, 'GET', null, token);
472
+ if (meRes.status === 200) {
473
+ user = meRes.data.user;
474
+ }
475
+
476
+ if (config.brain_id) {
477
+ const brainRes = await jsonRequest(
478
+ `${config.api_url}/api/brains/${config.brain_id}`,
479
+ 'GET', null, token
480
+ );
481
+ if (brainRes.status === 200) {
482
+ brain = brainRes.data;
483
+ }
484
+ }
485
+ } catch {
486
+ // Token may be expired — still report config
487
+ }
488
+
489
+ return {
490
+ connected: true,
491
+ api_url: config.api_url,
492
+ user_email: config.user_email || (user && user.email) || null,
493
+ brain_id: config.brain_id,
494
+ brain_name: brain ? brain.name : null,
495
+ brain_size: brain ? brain.size_bytes : null,
496
+ brain_files: brain ? brain.file_count : null,
497
+ last_synced: brain && brain.last_synced_at ? brain.last_synced_at : null,
498
+ last_push: config.last_push || null,
499
+ last_pull: config.last_pull || null,
500
+ connected_at: config.connected_at || null,
501
+ };
502
+ }
503
+
504
+ // ---------------------------------------------------------------------------
505
+ // Exports
506
+ // ---------------------------------------------------------------------------
507
+
508
+ module.exports = {
509
+ login,
510
+ logout,
511
+ push,
512
+ pull,
513
+ status,
514
+ readConfig,
515
+ writeConfig,
516
+ // Internal — exported for testing
517
+ requestDeviceCode,
518
+ pollDeviceCode,
519
+ getValidToken,
520
+ packBrain,
521
+ unpackBrain,
522
+ resolvePaths,
523
+ DEFAULT_API_URL,
524
+ };