@design-twin/dtwin 0.1.4 → 0.1.5

package/figma-plugin/code.js

@@ -4069,7 +4069,7 @@
             // freshly reloaded one, since neither startedAt nor code.js's mtime can. Reused verbatim by
             // the `hello` announcement below (main.ts's get-identity -> ui.html -> bridge), so `whoami`,
             // `dtwin list clients` and `dtwin doctor` can never disagree about which build is running.
-            pluginVersion: "0.1.4",
+            pluginVersion: "0.1.5",
             fileKey: fileKey === void 0 ? null : fileKey,
             fileKeyAvailable: typeof fileKey === "string" && fileKey.length > 0,
             // So figma_write's dry run can say a real write would be refused before anyone sends one.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@design-twin/dtwin",
-  "version": "0.1.4",
-  "description": "Figma → code with Claude Code: the dtwin CLI + MCP server (and the Figma plugin) that read a design on the free Figma plan into your project, fully offline.",
+  "version": "0.1.5",
+  "description": "Figma → code with Claude Code: the dtwin CLI + MCP server (and the Figma plugin) that read a design on the free Figma plan into your project. No REST API key, no cloud service in between.",
   "license": "MIT",
   "author": "Mohamed Magdy Omar",
   "repository": {

package/src/figma-pull.ts

@@ -894,7 +894,9 @@ async function openSession(parsed: ParsedArgs, settings: BridgeSettings): Promis
   // one gets more time once a plugin is connected, and with no target or a file name the fresh bridge
   // settles first (timeouts.ts SETTLE_MS), so a second open file a redial behind is connected — and the
   // command refused as ambiguous, or listed — instead of the first file to land being taken silently.
-  timing.connectMs = (await route.connect(client)).waitedMs;
+  // No plugin in the whole window fails here (route.ts), so no command prints "plugin connected — …" first; the
+  // clients listing alone answers "none".
+  timing.connectMs = (await route.connect(client, { listing: command.id === "listClients" })).waitedMs;
   // Where the time went, for the closing `done in …` line. The connect wait is measured above
   // (own bridge only — a daemon does its waiting inside the request), the export is the time inside
   // every request, the write is every write-out (read-run.ts adds both to `timing`). All measured from

package/src/route.ts

@@ -169,8 +169,10 @@ export interface RouteRequest {
 export interface Route {
   /** Spend the connect window (a one-shot route over its own bridge; otherwise nothing to wait for here) —
    *  once: later calls answer the first one's result. Requests and listClients call it themselves; a caller
-   *  calls it first only to time the wait. `target` is what that first wait waits for. */
-  connect(target?: string | null): Promise<{ waitedMs: number }>;
+   *  calls it first only to time the wait. `target` is what that first wait waits for. A window in which no plugin
+   *  ever connected throws the never-connected text here, before the caller says what it is about to do — unless
+   *  `listing` (the clients listing, whose answer is then "none"). */
+  connect(target?: string | null, o?: { listing?: boolean }): Promise<{ waitedMs: number }>;
   request<C extends Cmd>(cmd: C, args: Commands[C]["args"], o?: RouteRequest): Promise<Sent<C>>;
   listClients(): Promise<ClientRow[]>;
   /** The socket half of whoami for `connId` (the connection a request was answered by), and who holds it. */
@@ -206,8 +208,9 @@ export function createRoute(upstream: () => Promise<Upstream>, policy: RoutePoli
   }
 
   return {
-    async connect(target) {
-      const { waitedMs } = await spend(await upstream(), target);
+    async connect(target, { listing = false } = {}) {
+      const { waitedMs, everConnected } = await spend(await upstream(), target);
+      if (everConnected === false && !listing) throw neverConnected(policy.connectWaitMs);
       return { waitedMs };
     },
     async request(cmd, args, o = {}) {