@devicelink/dlink 0.2.1 → 0.3.0

package/README.md

@@ -1,8 +1,6 @@
 # @devicelink/dlink
 
-DeviceLink CLI agent — secure, local-first device access with explicit user consent.
-
-Share files from your machine with AI assistants (ChatGPT, Claude, etc.) through the Model Context Protocol (MCP). Your files never leave your device — they're streamed in real-time with your explicit permission.
+DeviceLink lets you share folders from your computer with AI assistants (like ChatGPT) safely. Nothing is uploaded to the cloud to sit on a server: files stay on your machine until you allow access, and you stay in control.
 
 ## Install
 
@@ -10,58 +8,47 @@ Share files from your machine with AI assistants (ChatGPT, Claude, etc.) through
 npm install -g @devicelink/dlink
 ```
 
-## Quick Start
+## Quick start
 
 ```bash
 # Sign in with your DeviceLink account
 dlink signin
 
-# Share a directory
+# Pick a folder to share
 dlink share /path/to/project
 
-# That's it — ChatGPT can now access your shared files via MCP
+# You're set: your AI can use that folder when you connect it through DeviceLink
 ```
 
 ## Commands
 
-| Command | Description |
-|---------|-------------|
-| `dlink signin` | Authenticate with DeviceLink |
-| `dlink signout` | Sign out and revoke device access |
-| `dlink share <path>` | Share a directory with MCP clients |
-| `dlink status` | Show connection status |
-| `dlink debug on/off` | Toggle debug logging |
-
-## How It Works
-
-1. **Sign in** — authenticate via Google OAuth using a device code flow
-2. **Share directories** — choose which folders to make available
-3. **Connect** — the agent maintains a secure WebSocket connection to the DeviceLink bridge
-4. **Use** — AI assistants call tools (list files, read files, search, grep) through MCP
-5. **Control** — you see every tool call in real-time and can disconnect anytime
-
-## Security
+| Command | What it does |
+|---------|----------------|
+| `dlink signin` | Sign in to DeviceLink |
+| `dlink signout` | Sign out on this computer |
+| `dlink share <path>` | Share a folder with your AI |
+| `dlink status` | See whether you're connected |
 
-- **Files never stored on servers** — streamed in real-time only
-- **Ed25519 proof-of-possession** — device identity is cryptographically verified
-- **Encrypted credential storage** — AES-256-GCM with machine-bound keys
-- **Shared directory boundaries** — path traversal protection, symlink escape prevention
-- **Short-lived tokens** — access tokens expire in 30 seconds, auto-refreshed
+## How it works
 
-## Configuration
+1. **Sign in** with your account (you'll use your browser when asked).
+2. **Pick folders** you want the AI to be able to read.
+3. **Stay connected** so requests can reach your computer securely.
+4. **Use your AI** as usual: it can list and read files in the folders you shared.
+5. **Stop anytime**: sign out or disconnect if you want access to end.
 
-Environment variables (optional):
+## Security & privacy
 
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `DLINK_CONTROL_URL` | `https://api.devicelink.ai` | Controller API URL |
-| `DLINK_BRIDGE_URL` | `wss://api.devicelink.ai/ws` | Bridge WebSocket URL |
-| `DLINK_DEBUG` | `false` | Enable debug logging |
+- Your files are not kept on our servers for browsing; access happens when you're connected and allow it.
+- Your device is checked so only your account can use your shared folders.
+- Sign-in details are stored encrypted on this computer.
+- Shared folders are limited to what you picked, so the AI can't wander the rest of your disk.
+- Access is short-lived and refreshed automatically so old keys don't stick around.
 
 ## Requirements
 
-- Node.js 20 or later
-- Internet connection for authentication and MCP bridge
+- [Node.js](https://nodejs.org/) version 20 or newer
+- Internet access to sign in and stay connected
 
 ## License
 

package/index.js

@@ -692,7 +692,8 @@ var ConfigLoader = class {
       } catch {
       }
     }
-    return [];
+    const cwd = process.cwd();
+    return [this.createDirectoryFromPath(cwd)];
   }
   getDevice() {
     const deviceId = this.getDeviceId();
@@ -961,6 +962,13 @@ var Engine2 = class {
   getBus() {
     return this.bus;
   }
+  hasRunningJobs() {
+    for (const [, count] of this.laneActive) {
+      if (count > 0)
+        return true;
+    }
+    return false;
+  }
   register(jobType) {
     const name = jobType.options.name;
     if (this.registry.has(name)) {
@@ -1587,7 +1595,7 @@ var LoadConfigJob = class extends JobType {
     );
   }
   async run(input, ctx) {
-    ctx.notifier.info("Loading configuration...");
+    ctx.notifier.info("Loading configuration...", { scope: "system" /* System */ });
     const configLoader = ctx.engine.configurationContext.loader;
     const refreshRes = await ctx.engine.secrets.get("devicePrivateKey");
     configLoader.setPrivateKeyCache(refreshRes.ok && refreshRes.value ? refreshRes.value : void 0);
@@ -1610,13 +1618,14 @@ var LoadConfigJob = class extends JobType {
     return new LoadConfigOutput(true, config);
   }
   updateUi(config, ctx) {
-    ctx.notifier.info(`Control base URL: ${config.controlBaseUrl}`);
-    ctx.notifier.info(`Bridge WebSocket URL: ${config.bridgeWsUrl}`);
-    ctx.notifier.info(`Directories: ${config.directories.map((directory) => directory.path).join(", ")}`);
-    ctx.notifier.info(`Device: ${config.device?.id}`);
-    ctx.notifier.info(`Device name: ${config.device?.name}`);
-    ctx.notifier.info(`Device tag: ${config.device?.tag}`);
-    ctx.notifier.info(`Device keys public: ${config.device?.keys?.public ? "***" : "(none)"}`);
+    const sys = { scope: "system" /* System */ };
+    ctx.notifier.info(`Control base URL: ${config.controlBaseUrl}`, sys);
+    ctx.notifier.info(`Bridge WebSocket URL: ${config.bridgeWsUrl}`, sys);
+    ctx.notifier.info(`Directories: ${config.directories.map((directory) => directory.path).join(", ")}`, sys);
+    ctx.notifier.info(`Device: ${config.device?.id}`, sys);
+    ctx.notifier.info(`Device name: ${config.device?.name}`, sys);
+    ctx.notifier.info(`Device tag: ${config.device?.tag}`, sys);
+    ctx.notifier.info(`Device keys public: ${config.device?.keys?.public ? "***" : "(none)"}`, sys);
   }
 };
 var loadConfigJob = new LoadConfigJob();
@@ -3311,6 +3320,9 @@ var ConsoleOrchestrator = class {
             ctx.bus.emit("runtime:debug:changed", { enabled: false });
             ctx.notifier.success("Debug mode disabled");
             break;
+          case "replace" /* Replace */:
+            ctx.bus.emit("auth:session_conflict:resolve", { choice: "USE_NEW" });
+            break;
           default:
             ctx.notifier.warn(`Command not implemented: ${input.kind}`);
             break;
@@ -3360,6 +3372,9 @@ var ConsoleOrchestrator = class {
         if (cmd === "doctor") {
           return { handled: true, kind: "doctor" /* Doctor */ };
         }
+        if (cmd === "replace" || cmd === "yes" || cmd === "y") {
+          return { handled: true, kind: "replace" /* Replace */ };
+        }
       }
       return { handled: false };
     });
@@ -3809,7 +3824,6 @@ var WebSocketOrchestrator = class {
     };
     return {
       "config:cache:validated": async (_, ctx) => initSocket("config:cache:validated", ctx),
-      "auth:signin:completed": async (_, ctx) => initSocket("auth:signin:completed", ctx),
       "auth:signout:requested": async (_, ctx) => {
         ctx.notifier.info("WS: sign-out requested -> disconnecting");
         this.stopped = true;
@@ -3828,7 +3842,10 @@ var WebSocketOrchestrator = class {
         ctx.notifier.info("WS: reconnect requested by auth", { scope: "system" /* System */ });
         this.retryAttempt = 0;
         this.clearCountdown();
-        this.socket?.disconnect(false);
+        if (this.socket) {
+          this.socket.stop();
+          this.socket = null;
+        }
         this.ensureStarted(ctx, "auth:ws:reconnect");
       },
       // the only sender
@@ -3847,6 +3864,11 @@ var WebSocketOrchestrator = class {
       ctx.notifier.info(`WS: connect loop already running (reason=${reason})`, { scope: "system" /* System */ });
       return;
     }
+    const ws = this.socket?.getSocket();
+    if (ws && ws.readyState <= 1) {
+      ctx.notifier.info(`WS: already connected/connecting, skipping (reason=${reason})`, { scope: "system" /* System */ });
+      return;
+    }
     this.connectLoopInFlight = this.startOrJoinConnectLoop(ctx, reason).finally(() => {
       this.connectLoopInFlight = null;
     });
@@ -3861,32 +3883,47 @@ var WebSocketOrchestrator = class {
     this.lastUrl = url;
     ctx.notifier.info(`WS: ensure connection (reason=${reason}) url=${url}`, { scope: "system" /* System */ });
     if (!this.socket) {
-      this.socket = new RecoverableSocket(url, {
+      const sock = new RecoverableSocket(url, {
         abortSignal: ctx.signal,
         connectionTimeoutMs: 1e4,
         heartbeatIntervalMs: 2e4,
         pongTimeoutMs: 1e4
       });
-      this.socket.registerOnStateChangeCallback((state) => this.handleStateChange(state, ctx));
-      this.socket.registerOnErrorCallback((error) => {
+      this.socket = sock;
+      sock.registerOnStateChangeCallback((state) => this.handleStateChange(state, ctx));
+      sock.registerOnErrorCallback((error) => {
         ctx.notifier.error(`WS: transport error: ${error.message}`);
       });
-      this.socket.registerOnConnectedCallback((_ws) => {
+      sock.registerOnConnectedCallback((_ws) => {
+        if (this.socket !== sock)
+          return;
         this.retryAttempt = 0;
         this.clearCountdown();
-        ctx.notifier.success(`WS: connected (${url})`);
+        ctx.notifier.success(ctx.flags.debug ? `WS: connected (${url})` : `WS: connected`);
         ctx.bus.emit("ws:connected", { url, attempt: 0 });
       });
-      this.socket.registerOnDisconnectedCallback((code, reasonStr) => {
+      sock.registerOnDisconnectedCallback((code, reasonStr) => {
+        if (this.socket !== sock) {
+          ctx.notifier.info(`WS: ignoring stale disconnect (code=${code})`, { scope: "system" /* System */ });
+          return;
+        }
         ctx.notifier.warn(`WS: disconnected code=${code} reason=${reasonStr || "-"}`);
         ctx.bus.emit("ws:disconnected", { code, reason: reasonStr });
         if (code === 4001) {
           ctx.notifier.info("WS: auth disconnect (4001) -> waiting for auth", { scope: "system" /* System */ });
           return;
         }
+        if (code === 4011) {
+          this.stopped = true;
+          this.socket?.stop();
+          this.socket = null;
+          return;
+        }
         this.ensureStarted(ctx, "socket:disconnected");
       });
-      this.socket.registerOnMessageCallback((data) => {
+      sock.registerOnMessageCallback((data) => {
+        if (this.socket !== sock)
+          return;
         const text = typeof data === "string" ? data : data.toString("utf8");
         ctx.bus.emit("ws:rx", { text });
       });
@@ -4557,6 +4594,7 @@ var AuthOrchestrator = class {
   connectionId = null;
   sessionId = null;
   accessToken;
+  rejectedByConflict = false;
   refreshGroupKey = "auth:refresh";
   refreshCycle = 0;
   refreshScheduler = null;
@@ -4590,6 +4628,11 @@ var AuthOrchestrator = class {
           "Auth: signin completed; requesting ws reconnect",
           { scope: "system" /* System */ }
         );
+        this.rejectedByConflict = false;
+        if (this.refreshRetryScheduler) {
+          this.refreshRetryScheduler.stop();
+          this.refreshRetryScheduler = null;
+        }
         this.ensureAccessExpPersisted(ctx, "signin");
         await this.ensureRefreshScheduling(ctx, "signin");
         ctx.bus.emit("auth:ws:reconnect", void 0);
@@ -4646,6 +4689,14 @@ var AuthOrchestrator = class {
           { scope: "system" /* System */ }
         );
         this.resetConnectionState();
+        if (p.code === 4011) {
+          ctx.notifier.warn(
+            'Connection rejected - another device is active on this workspace. Run "signin" to try again.'
+          );
+          this.rejectedByConflict = true;
+          ctx.bus.emit("ws:disconnect", { reason: "REPLACEMENT_REJECTED" });
+          return;
+        }
         if (p.code === 4001) {
           const refreshRes = await ctx.engine.secrets.get("refreshToken");
           if (!refreshRes.ok || !refreshRes.value) {
@@ -4668,7 +4719,8 @@ var AuthOrchestrator = class {
   // --- boot path unchanged except it must schedule refresh always ---
   async onEventConfigLoaded(config, ctx) {
     ctx.notifier.info(
-      "Initializing with cached configuration"
+      "Initializing with cached configuration",
+      { scope: "system" /* System */ }
     );
     if (!config.device?.id) {
       ctx.notifier.error("Device ID is not available");
@@ -4697,7 +4749,6 @@ var AuthOrchestrator = class {
       ctx.notifier.warn("Auth: not signed in; run signin");
       return;
     }
-    ctx.bus.emit("auth:ws:reconnect", void 0);
   }
   isAccessLikelyUsable(ctx) {
     const jwt = this.accessToken;
@@ -4714,7 +4765,8 @@ var AuthOrchestrator = class {
   async waitForApproval(api, startResponse, ctx) {
     const deadline = Date.now() + startResponse.expires_in * 1e3;
     ctx.notifier.info(
-      "Waiting for approval... (streaming)"
+      "Waiting for approval... (streaming)",
+      { scope: "system" /* System */ }
     );
     try {
       return await api.deviceAuthStream({
@@ -4811,7 +4863,8 @@ var AuthOrchestrator = class {
       }
       if (streamResp.needs_proof) {
         ctx.notifier.info(
-          "Sending proof-of-possession signature..."
+          "Sending proof-of-possession signature...",
+          { scope: "system" /* System */ }
         );
         const privKeyObj = crypto8.createPrivateKey(privateKeyPem);
         const challengeBytes = Buffer.from(
@@ -4826,9 +4879,9 @@ var AuthOrchestrator = class {
           challenge: startResponse.challenge,
           signature_b64: signatureB64
         });
-        ctx.notifier.info("Proof-of-possession verified");
+        ctx.notifier.info("Proof-of-possession verified", { scope: "system" /* System */ });
       }
-      ctx.notifier.info("Fetching tokens...");
+      ctx.notifier.info("Fetching tokens...", { scope: "system" /* System */ });
       const tokenResp = await api.deviceAuthToken({
         device_code: startResponse.device_code
       });
@@ -4962,6 +5015,9 @@ var AuthOrchestrator = class {
         ctx.bus.emit("auth:session_conflict", msg);
         void this.handleSessionConflict(ctx, msg);
         return;
+      case "quiesce":
+        void this.handleQuiesce(ctx, msg);
+        return;
       default:
         return;
     }
@@ -4972,14 +5028,41 @@ var AuthOrchestrator = class {
       this.conflictTimer = null;
     }
     this.pendingConflictRequest = msg;
+    ctx.notifier.warn(
+      `Another device is already connected to this workspace. Type "replace" to disconnect it, or this connection will be rejected in ${Math.round(msg.deadline_ms / 1e3)}s.`
+    );
     const deadlineMs = Math.min(msg.deadline_ms, 15e3);
     this.conflictTimer = setTimeout(() => {
       this.conflictTimer = null;
       if (this.pendingConflictRequest?.new_session_id === msg.new_session_id) {
+        ctx.notifier.info("No response - keeping existing device connected.");
         this.sendSessionConflictResolve(ctx, "KEEP_OLD");
       }
     }, deadlineMs);
   }
+  async handleQuiesce(ctx, msg) {
+    ctx.notifier.warn(
+      `This device is being replaced by another connection. Finishing in-flight operations...`
+    );
+    const hasActiveJobs = ctx.engine.hasRunningJobs?.() ?? false;
+    if (hasActiveJobs) {
+      const deadline = Math.min(msg.deadline_ms - 2e3, 12e3);
+      const start = Date.now();
+      while (Date.now() - start < deadline) {
+        if (!(ctx.engine.hasRunningJobs?.() ?? false))
+          break;
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+    const status = ctx.engine.hasRunningJobs?.() ?? false ? "BUSY" : "IDLE";
+    this.send(ctx, {
+      type: "quiesce_ack",
+      session_id: msg.session_id,
+      status
+    });
+    ctx.notifier.info("Device replaced by new connection. Disconnecting.");
+    this.socket?.stop();
+  }
   sendSessionConflictResolve(ctx, choice) {
     const req = this.pendingConflictRequest;
     if (!req)
@@ -5241,6 +5324,10 @@ var AuthOrchestrator = class {
     if (this.accessToken && !ctx.engine.configurationContext.configuration.tokens?.accessTokenExpSec) {
       this.ensureAccessExpPersisted(ctx, reason);
     }
+    if (this.refreshRetryScheduler) {
+      this.refreshRetryScheduler.stop();
+      this.refreshRetryScheduler = null;
+    }
     this.scheduleSilentRefresh(ctx, reason);
   }
   async scheduleSilentRefresh(ctx, reason) {
@@ -7676,6 +7763,7 @@ var ToolsOrchestrator = class {
     const availableDirectoryIds = config.directories.map((r) => r.id).join(", ") || "none";
     const availableDirectoryPaths = config.directories.map((r) => r.path).join(", ") || "none";
     ctx.notifier.info(`Tool call: ${toolName} (job=${jobId}, directory_id=${directoryId || "MISSING"}, available_ids=[${availableDirectoryIds}], available_paths=[${availableDirectoryPaths}], directory_count=${config.directories.length})`, { scope: "system" /* System */ });
+    ctx.notifier.info(`Executing: ${toolName}`);
     const toolStartTime = Date.now();
     try {
       const toolRegistry = new ToolExecuterRegistry(config);
@@ -7686,9 +7774,9 @@ var ToolsOrchestrator = class {
       const timing = calculateTiming(toolStartTime);
       const result = createToolResult(toolName, jobId, raw, timing.execution_sec);
       if (result.ok) {
-        ctx.notifier.success(result.toString(), { ts: Date.now(), kind: "success" /* Success */, scope: "system" /* System */ });
+        ctx.notifier.success(result.toString());
       } else {
-        ctx.notifier.error(result.toString(), { scope: "system" /* System */ });
+        ctx.notifier.error(result.toString());
       }
     } catch (e) {
       const toolResult = formatToolErrorResponse(jobId, toolName, e, toolStartTime);
@@ -7700,7 +7788,7 @@ var ToolsOrchestrator = class {
         error: e instanceof Error ? { code: "INTERNAL", message: e.message } : { code: "INTERNAL", message: String(e) }
       };
       const result = createToolResult(toolName, jobId, errorResult, timing.execution_sec);
-      ctx.notifier.error(result.toString(), { scope: "system" /* System */ });
+      ctx.notifier.error(result.toString());
     }
   }
 };