botsync 0.1.0

package/README.md

@@ -0,0 +1,37 @@
+# botsync
+
+P2P file sync for AI agents. Two commands. No server.
+
+## Quick Start
+
+```bash
+# On machine A (your agent):
+npx botsync init
+# Share the passphrase with machine B
+
+# On machine B (you):
+npx botsync join <passphrase>
+
+# That's it. ~/sync/ is now shared.
+```
+
+## Folder Convention
+
+| Folder | Purpose |
+|--------|---------|
+| `shared/` | Bidirectional — both sides read and write |
+| `deliverables/` | Agent drops outputs here for human review |
+| `inbox/` | Human drops files here for agent to process |
+
+## Commands
+
+```bash
+botsync init              # Initialize and start syncing
+botsync join <passphrase> # Connect to another botsync instance
+botsync status            # Show sync status
+botsync stop              # Stop the sync daemon
+```
+
+## How It Works
+
+botsync wraps [Syncthing](https://syncthing.net/) — a battle-tested, open-source P2P sync engine. No central server, no cloud accounts, no configuration files to edit. Just a passphrase that encodes everything needed to connect two machines.

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * cli.ts — Entry point for the botsync CLI.
+ *
+ * Routes commands to their handlers. The shebang line makes it
+ * executable as `npx botsync` or a globally installed CLI.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * cli.ts — Entry point for the botsync CLI.
+ *
+ * Routes commands to their handlers. The shebang line makes it
+ * executable as `npx botsync` or a globally installed CLI.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const join_js_1 = require("./commands/join.js");
+const status_js_1 = require("./commands/status.js");
+const stop_js_1 = require("./commands/stop.js");
+const ui = __importStar(require("./ui.js"));
+const program = new commander_1.Command();
+program
+    .name("botsync")
+    .description("P2P file sync for AI agents.")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Initialize botsync and start syncing. Prints a passphrase for pairing.")
+    .action(async () => {
+    try {
+        await (0, init_js_1.init)();
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command("join <passphrase>")
+    .description("Connect to another botsync instance using a passphrase.")
+    .action(async (passphrase) => {
+    try {
+        await (0, join_js_1.join)(passphrase);
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command("status")
+    .description("Show sync status — peers, folders, sync progress.")
+    .action(async () => {
+    try {
+        await (0, status_js_1.status)();
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command("stop")
+    .description("Stop the botsync daemon.")
+    .action(async () => {
+    try {
+        await (0, stop_js_1.stop)();
+    }
+    catch (err) {
+        ui.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/commands/init.d.ts

@@ -0,0 +1,13 @@
+/**
+ * init.ts — The `botsync init` command.
+ *
+ * This is the "machine A" side of the pairing flow. It:
+ * 1. Creates the ~/sync/ directory structure
+ * 2. Downloads Syncthing if needed
+ * 3. Generates config with sane defaults
+ * 4. Starts the daemon
+ * 5. Waits for it to come online
+ * 6. Produces a passphrase that encodes everything "machine B" needs to connect
+ * 7. Polls for the joining device and auto-accepts it
+ */
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * init.ts — The `botsync init` command.
+ *
+ * This is the "machine A" side of the pairing flow. It:
+ * 1. Creates the ~/sync/ directory structure
+ * 2. Downloads Syncthing if needed
+ * 3. Generates config with sane defaults
+ * 4. Starts the daemon
+ * 5. Waits for it to come online
+ * 6. Produces a passphrase that encodes everything "machine B" needs to connect
+ * 7. Polls for the joining device and auto-accepts it
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const config_js_1 = require("../config.js");
+const syncthing_js_1 = require("../syncthing.js");
+const passphrase_js_1 = require("../passphrase.js");
+const ui = __importStar(require("../ui.js"));
+/**
+ * Pick a random port in the ephemeral range for the Syncthing REST API.
+ * We avoid 8384 (Syncthing's default) to not conflict with any existing
+ * Syncthing installation the user might have.
+ */
+function randomPort() {
+    return 27000 + Math.floor(Math.random() * 10000);
+}
+async function init() {
+    ui.header();
+    // Step 1: Create directory structure
+    for (const folder of config_js_1.FOLDERS) {
+        (0, fs_1.mkdirSync)(folder.path, { recursive: true });
+    }
+    (0, fs_1.mkdirSync)(config_js_1.BOTSYNC_DIR, { recursive: true });
+    (0, fs_1.mkdirSync)(config_js_1.SYNCTHING_CONFIG_DIR, { recursive: true });
+    ui.stepDone("Sync folders created");
+    // Step 2: Download Syncthing binary (skips if already present)
+    await (0, syncthing_js_1.downloadSyncthing)();
+    ui.stepDone("Syncthing ready");
+    // Step 3: Generate config
+    const apiKey = (0, crypto_1.randomUUID)();
+    const apiPort = randomPort();
+    const configXml = (0, syncthing_js_1.generateConfig)(apiKey, apiPort);
+    (0, fs_1.writeFileSync)(`${config_js_1.SYNCTHING_CONFIG_DIR}/config.xml`, configXml);
+    (0, config_js_1.writeConfig)({ apiKey, apiPort });
+    // Step 4: Start the daemon
+    const pid = (0, syncthing_js_1.startDaemon)();
+    ui.stepDone(`Daemon started (PID ${pid})`);
+    // Step 5: Wait for Syncthing to be ready and get our device ID
+    const spin = ui.spinner("Starting Syncthing...");
+    await (0, syncthing_js_1.waitForStart)();
+    spin.succeed();
+    const deviceId = await (0, syncthing_js_1.getDeviceId)();
+    (0, config_js_1.writeConfig)({ apiKey, apiPort, deviceId });
+    // Step 6: Register with relay and display the code
+    ui.gap();
+    const { code, isRelay } = await (0, passphrase_js_1.createCode)({
+        deviceId,
+        folders: config_js_1.FOLDERS.map((f) => f.id),
+    });
+    if (isRelay) {
+        ui.passphraseBox(code, `npx botsync join ${code}`);
+        ui.info("Code expires in 10 minutes.");
+    }
+    else {
+        ui.info("Relay unavailable — using offline passphrase:");
+        ui.gap();
+        ui.passphraseBox(code, `npx botsync join ${code.substring(0, 20)}...`);
+    }
+    ui.gap();
+    // Step 7: Wait for the joining device to connect and auto-accept it
+    const peerSpin = ui.spinner("Waiting for peer...");
+    const accepted = await waitForPeer(apiKey, apiPort, peerSpin);
+    if (accepted) {
+        peerSpin.stop();
+        ui.paired(accepted);
+    }
+}
+/**
+ * Poll for pending device connections and auto-accept the first one.
+ * After accepting the device, share all botsync folders with it.
+ *
+ * Times out after 5 minutes — if nobody joins by then, they can still
+ * join later (they'll just show up as pending until the user restarts
+ * init or manually approves via the API).
+ */
+async function waitForPeer(apiKey, apiPort, spin, timeoutMs = 300_000) {
+    const start = Date.now();
+    const pollInterval = 2000;
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const pending = await (0, syncthing_js_1.apiCall)("GET", "/rest/cluster/pending/devices");
+            const deviceIds = Object.keys(pending);
+            if (deviceIds.length > 0) {
+                const peerId = deviceIds[0];
+                spin.text = `Accepting ${peerId.substring(0, 7)}...`;
+                // Add the device to our config
+                await (0, syncthing_js_1.addDevice)(peerId);
+                // Share all folders with it
+                for (const folder of config_js_1.FOLDERS) {
+                    await (0, syncthing_js_1.addDeviceToFolder)(folder.id, peerId);
+                }
+                return peerId;
+            }
+        }
+        catch {
+            // API might hiccup during config changes — ignore and retry
+        }
+        await new Promise((r) => setTimeout(r, pollInterval));
+    }
+    spin.stop();
+    ui.info("No peer connected within 5 minutes.");
+    ui.info("The passphrase is still valid — join anytime, then restart init.");
+    ui.gap();
+    return null;
+}

package/dist/commands/join.d.ts

@@ -0,0 +1,13 @@
+/**
+ * join.ts — The `botsync join <passphrase>` command.
+ *
+ * This is the "machine B" side of the pairing flow. It:
+ * 1. Decodes the passphrase to get the init side's device ID + folder list
+ * 2. Creates the local directory structure
+ * 3. Downloads Syncthing if needed
+ * 4. Generates config
+ * 5. Starts the daemon
+ * 6. Adds the init side as a known device
+ * 7. Shares all folders with the init side
+ */
+export declare function join(passphrase: string): Promise<void>;

package/dist/commands/join.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * join.ts — The `botsync join <passphrase>` command.
+ *
+ * This is the "machine B" side of the pairing flow. It:
+ * 1. Decodes the passphrase to get the init side's device ID + folder list
+ * 2. Creates the local directory structure
+ * 3. Downloads Syncthing if needed
+ * 4. Generates config
+ * 5. Starts the daemon
+ * 6. Adds the init side as a known device
+ * 7. Shares all folders with the init side
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = join;
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const config_js_1 = require("../config.js");
+const syncthing_js_1 = require("../syncthing.js");
+const passphrase_js_1 = require("../passphrase.js");
+const ui = __importStar(require("../ui.js"));
+async function join(passphrase) {
+    ui.header();
+    // Resolve the code — tries relay first, falls back to base58
+    const spin0 = ui.spinner("Resolving pairing code...");
+    let remoteId;
+    let folders;
+    try {
+        const data = await (0, passphrase_js_1.resolveCode)(passphrase);
+        remoteId = data.deviceId;
+        folders = data.folders;
+        spin0.succeed();
+    }
+    catch (err) {
+        spin0.fail();
+        ui.error(err instanceof Error ? err.message : "Failed to resolve code");
+        process.exit(1);
+    }
+    const short = remoteId.substring(0, 7);
+    ui.info(`Connecting to ${short}...`);
+    ui.gap();
+    // First time? Set up everything
+    const existing = (0, config_js_1.readConfig)();
+    if (!existing) {
+        for (const folder of config_js_1.FOLDERS) {
+            (0, fs_1.mkdirSync)(folder.path, { recursive: true });
+        }
+        (0, fs_1.mkdirSync)(config_js_1.BOTSYNC_DIR, { recursive: true });
+        (0, fs_1.mkdirSync)(config_js_1.SYNCTHING_CONFIG_DIR, { recursive: true });
+        await (0, syncthing_js_1.downloadSyncthing)();
+        ui.stepDone("Syncthing ready");
+        const apiKey = (0, crypto_1.randomUUID)();
+        const apiPort = 27000 + Math.floor(Math.random() * 10000);
+        const configXml = (0, syncthing_js_1.generateConfig)(apiKey, apiPort);
+        (0, fs_1.writeFileSync)(`${config_js_1.SYNCTHING_CONFIG_DIR}/config.xml`, configXml);
+        (0, config_js_1.writeConfig)({ apiKey, apiPort });
+        const pid = (0, syncthing_js_1.startDaemon)();
+        ui.stepDone(`Daemon started (PID ${pid})`);
+        const spin = ui.spinner("Starting Syncthing...");
+        await (0, syncthing_js_1.waitForStart)();
+        spin.succeed();
+        const myId = await (0, syncthing_js_1.getDeviceId)();
+        (0, config_js_1.writeConfig)({ apiKey, apiPort, deviceId: myId });
+    }
+    // Add the remote device and share folders
+    const spin2 = ui.spinner("Pairing...");
+    await (0, syncthing_js_1.addDevice)(remoteId);
+    for (const folderId of folders) {
+        await (0, syncthing_js_1.addDeviceToFolder)(folderId, remoteId);
+    }
+    spin2.stop();
+    ui.connected(remoteId);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * status.ts — The `botsync status` command.
+ *
+ * Shows connected peers, device ID, and per-folder sync state.
+ */
+export declare function status(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * status.ts — The `botsync status` command.
+ *
+ * Shows connected peers, device ID, and per-folder sync state.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+const config_js_1 = require("../config.js");
+const syncthing_js_1 = require("../syncthing.js");
+const ui = __importStar(require("../ui.js"));
+async function status() {
+    const config = (0, config_js_1.readConfig)();
+    if (!config) {
+        ui.notRunning();
+        return;
+    }
+    // Check if daemon is actually running
+    try {
+        await (0, syncthing_js_1.apiCall)("GET", "/rest/system/status");
+    }
+    catch {
+        ui.notRunning();
+        return;
+    }
+    // Get connections
+    const connections = await (0, syncthing_js_1.apiCall)("GET", "/rest/system/connections");
+    const peers = Object.values(connections.connections).filter((c) => c.connected).length;
+    // Get folder statuses
+    const folders = [];
+    for (const f of config_js_1.FOLDERS) {
+        try {
+            const s = await (0, syncthing_js_1.apiCall)("GET", `/rest/db/status?folder=${f.id}`);
+            const synced = s.state === "idle" && s.needFiles === 0;
+            const state = synced ? "idle" : s.state;
+            folders.push({
+                name: f.id.replace("botsync-", ""),
+                synced,
+                state,
+                lastChange: s.stateChanged,
+            });
+        }
+        catch {
+            folders.push({ name: f.id.replace("botsync-", ""), synced: false, state: "unknown" });
+        }
+    }
+    ui.statusTable(peers, config.deviceId || "unknown", folders);
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stop.ts — The `botsync stop` command.
+ *
+ * Stops the Syncthing daemon.
+ */
+export declare function stop(): Promise<void>;

package/dist/commands/stop.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * stop.ts — The `botsync stop` command.
+ *
+ * Stops the Syncthing daemon.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stop = stop;
+const syncthing_js_1 = require("../syncthing.js");
+const ui = __importStar(require("../ui.js"));
+async function stop() {
+    const killed = (0, syncthing_js_1.stopDaemon)();
+    if (killed) {
+        ui.stopped();
+    }
+    else {
+        ui.notRunning();
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * config.ts — Central configuration and path management for botsync.
+ *
+ * All paths are derived from the user's home directory. The sync root is ~/sync/,
+ * and botsync's internal state lives in ~/sync/.botsync/. We also store the
+ * syncthing binary in ~/.botsync/bin/ (outside the sync dir so it doesn't get synced).
+ *
+ * config.json is the runtime state file — it stores the API key, port, device ID,
+ * and PID so that all commands can talk to the running Syncthing instance.
+ */
+export declare const SYNC_DIR: string;
+export declare const BOTSYNC_DIR: string;
+export declare const SYNCTHING_CONFIG_DIR: string;
+export declare const SYNCTHING_BIN_DIR: string;
+export declare const SYNCTHING_BIN: string;
+export declare const CONFIG_FILE: string;
+export declare const PID_FILE: string;
+export declare const FOLDERS: {
+    id: string;
+    path: string;
+}[];
+/** Runtime config shape — everything we need to talk to Syncthing */
+export interface BotsyncConfig {
+    apiKey: string;
+    apiPort: number;
+    deviceId?: string;
+}
+/** Read the config file, or return null if it doesn't exist */
+export declare function readConfig(): BotsyncConfig | null;
+/** Write config to disk. Creates parent dirs if needed. */
+export declare function writeConfig(config: BotsyncConfig): void;

package/dist/config.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * config.ts — Central configuration and path management for botsync.
+ *
+ * All paths are derived from the user's home directory. The sync root is ~/sync/,
+ * and botsync's internal state lives in ~/sync/.botsync/. We also store the
+ * syncthing binary in ~/.botsync/bin/ (outside the sync dir so it doesn't get synced).
+ *
+ * config.json is the runtime state file — it stores the API key, port, device ID,
+ * and PID so that all commands can talk to the running Syncthing instance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOLDERS = exports.PID_FILE = exports.CONFIG_FILE = exports.SYNCTHING_BIN = exports.SYNCTHING_BIN_DIR = exports.SYNCTHING_CONFIG_DIR = exports.BOTSYNC_DIR = exports.SYNC_DIR = void 0;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+// BOTSYNC_ROOT env var overrides the default ~/sync/ location.
+// Useful for testing without touching a production sync folder.
+const root = process.env.BOTSYNC_ROOT || (0, path_1.join)((0, os_1.homedir)(), "sync");
+// Where synced files live — the user-facing directory
+exports.SYNC_DIR = root;
+// Internal botsync state — inside sync dir but gitignored by Syncthing
+exports.BOTSYNC_DIR = (0, path_1.join)(exports.SYNC_DIR, ".botsync");
+// Syncthing config/data lives here (inside .botsync so it's co-located)
+exports.SYNCTHING_CONFIG_DIR = (0, path_1.join)(exports.BOTSYNC_DIR, "syncthing");
+// Where we store the syncthing binary — outside sync dir to avoid syncing a binary
+exports.SYNCTHING_BIN_DIR = (0, path_1.join)((0, os_1.homedir)(), ".botsync", "bin");
+exports.SYNCTHING_BIN = (0, path_1.join)(exports.SYNCTHING_BIN_DIR, "syncthing");
+// Runtime config file — API key, port, device ID, PID
+exports.CONFIG_FILE = (0, path_1.join)(exports.BOTSYNC_DIR, "config.json");
+// PID file for the daemon
+exports.PID_FILE = (0, path_1.join)(exports.BOTSYNC_DIR, "daemon.pid");
+// The three standard sync folders
+exports.FOLDERS = [
+    { id: "botsync-shared", path: (0, path_1.join)(exports.SYNC_DIR, "shared") },
+    { id: "botsync-deliverables", path: (0, path_1.join)(exports.SYNC_DIR, "deliverables") },
+    { id: "botsync-inbox", path: (0, path_1.join)(exports.SYNC_DIR, "inbox") },
+];
+/** Read the config file, or return null if it doesn't exist */
+function readConfig() {
+    try {
+        const raw = (0, fs_1.readFileSync)(exports.CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Write config to disk. Creates parent dirs if needed. */
+function writeConfig(config) {
+    (0, fs_1.mkdirSync)(exports.BOTSYNC_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(exports.CONFIG_FILE, JSON.stringify(config, null, 2));
+}