lineadraw 0.7.0 → 0.9.0

package/bin/lineadraw.mjs

@@ -10,7 +10,7 @@
 //     `call`, `tools`. Reads the desktop's bridge.json for the port
 //     and the agent token; `--port` / `--token` / LINEA_BRIDGE_TOKEN override.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { isDeepStrictEqual } from "node:util";
 import { dirname, join, resolve } from "node:path";
 import {
   buildManifest,
@@ -66,130 +66,36 @@ const parseArgs = (argv) => {
 };
 
 // --- bridge --------------------------------------------------------------
-
-const APP_ID = "com.lineadraw.desktop";
-const DEFAULT_PORT = 7431;
-
-const bridgeFilePath = () => {
-  const home = homedir();
-  if (process.platform === "win32")
-    return join(
-      process.env.APPDATA ?? join(home, "AppData", "Roaming"),
-      APP_ID,
-      "bridge.json",
-    );
-  if (process.platform === "darwin")
-    return join(home, "Library", "Application Support", APP_ID, "bridge.json");
-  return join(
-    process.env.XDG_DATA_HOME ?? join(home, ".local", "share"),
-    APP_ID,
-    "bridge.json",
-  );
-};
-
-const readBridgeFile = () => {
-  const path = bridgeFilePath();
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return {};
-  }
-};
-
-const bridge = (flags) => {
-  const file = readBridgeFile();
-  const port =
-    typeof flags.port === "string"
-      ? Number(flags.port)
-      : file.port || DEFAULT_PORT;
-  const token =
-    (typeof flags.token === "string" ? flags.token : undefined) ??
-    process.env.LINEA_BRIDGE_TOKEN ??
-    file.token;
-  const headers = { "content-type": "application/json" };
-  if (token) headers.authorization = `Bearer ${token}`;
-  return { base: `http://127.0.0.1:${port}`, headers };
-};
-
-const request = async (b, method, path, body) => {
-  let response;
-  try {
-    response = await fetch(`${b.base}${path}`, {
-      method,
-      headers: b.headers,
-      body: body === undefined ? undefined : JSON.stringify(body),
-    });
-  } catch (e) {
-    const cause = e?.cause?.code ?? e?.cause?.message ?? e?.message ?? e;
-    throw new Error(
-      `Nothing answers on ${b.base} (${cause}). Is the Linea desktop app running?`,
-      { cause: e },
-    );
-  }
-  const text = await response.text();
-  let parsed = text;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    // not JSON: keep the text
-  }
-  if (!response.ok) {
-    const error = parsed?.error;
-    throw new Error(
-      error?.message ?? `HTTP ${response.status}: ${text.slice(0, 200)}`,
-    );
-  }
-  return parsed;
-};
-
-const editorQuery = (flags) =>
-  typeof flags.editor === "string"
-    ? `?editor=${encodeURIComponent(flags.editor)}`
-    : "";
+// The client is lineadraw/sdk's (src/bridge.ts), built on its own as
+// dist/bridge.js so these commands never load the kernel.
 
 const bridgeCommand = async (cmd, positional, flags) => {
-  const b = bridge(flags);
+  const { createBridge } = await import("../dist/bridge.js");
+  const b = createBridge({
+    port: typeof flags.port === "string" ? Number(flags.port) : undefined,
+    token: typeof flags.token === "string" ? flags.token : undefined,
+  });
+  const editor = typeof flags.editor === "string" ? flags.editor : undefined;
   switch (cmd) {
     case "status":
-      return request(b, "GET", "/status");
+      return b.status();
     case "open": {
       const file = positional[0];
       if (!file) throw new Error("open needs a .linea file path");
-      return request(b, "POST", "/api/linea_open_editor", {
-        path: resolve(file),
-      });
+      return b.open(file);
     }
     case "close":
-      return request(
-        b,
-        "POST",
-        `/api/linea_close_document${editorQuery(flags)}`,
-        { discard: flags.discard === true },
-      );
+      return b.editor(editor).close({ discard: flags.discard === true });
     case "call": {
       const [operation, json] = positional;
       if (!operation)
         throw new Error("call needs an operation name (see `lineadraw tools`)");
-      const payload = json === undefined ? {} : JSON.parse(json);
-      return request(
-        b,
-        "POST",
-        `/api/${encodeURIComponent(operation)}${editorQuery(flags)}`,
-        payload,
-      );
-    }
-    case "tools": {
-      const reply = await request(b, "POST", "/mcp", {
-        jsonrpc: "2.0",
-        id: 1,
-        method: "tools/list",
+      return b.call(operation, json === undefined ? {} : JSON.parse(json), {
+        editor,
       });
-      return (reply.result?.tools ?? []).map((t) => ({
-        name: t.name,
-        description: t.description,
-      }));
     }
+    case "tools":
+      return b.tools();
     default:
       throw new Error(`Unknown command: ${cmd}\n\n${USAGE}`);
   }
@@ -238,13 +144,27 @@ switch (command) {
   case "check": {
     const manifest = await validatedManifest();
     const committedPath = join(dir, MANIFEST_PATH);
-    const committed = existsSync(committedPath)
-      ? readFileSync(committedPath, "utf8")
-      : null;
-    if (committed !== manifestJson(manifest))
+    // Compared as parsed JSON, not bytes: a formatter, a web edit or a CRLF
+    // checkout must not fail a manifest whose content is current.
+    let committed = null;
+    if (existsSync(committedPath)) {
+      try {
+        committed = JSON.parse(readFileSync(committedPath, "utf8"));
+      } catch {
+        committed = "unreadable";
+      }
+    }
+    if (!isDeepStrictEqual(committed, JSON.parse(manifestJson(manifest)))) {
+      const why =
+        committed === null
+          ? "missing"
+          : committed === "unreadable"
+            ? "not valid JSON"
+            : "stale";
       fail(
-        `${MANIFEST_PATH} is ${committed === null ? "missing" : "stale"} — run \`npx lineadraw manifest\` and commit the result.`,
+        `${MANIFEST_PATH} is ${why} — run \`npx lineadraw manifest\` and commit the result.`,
       );
+    }
     const libWarning = tsconfigLibWarning(dir);
     if (libWarning !== null) console.warn(`warning: ${libWarning}`);
     console.log(`OK: ${manifest.entries.length} entries, manifest is current.`);

package/dist/bridge.d.ts

@@ -0,0 +1,102 @@
+declare const DEFAULT_BRIDGE_PORT = 7431;
+/** A running editor as the bridge lists it. */
+interface EditorInfo {
+    /** The drawing's document id — the stable way to address it. */
+    id: string;
+    name: string;
+    /** The file it is bound to; absent for an unsaved drawing / a web tab. */
+    path?: string | null;
+    kind: "desktop" | "web";
+    readOnly: boolean;
+    /** Changed since the last file save. */
+    dirty: boolean;
+}
+/** `GET /status`: the app's version, the bridge port, the open editors. */
+interface BridgeStatus {
+    version: string;
+    port: number;
+    editors: EditorInfo[];
+}
+interface BridgeOptions {
+    /** Default: bridge.json's port, else 7431. */
+    port?: number;
+    /** Agent token, when the app requires one. Default: LINEA_BRIDGE_TOKEN,
+     * else bridge.json's token. */
+    token?: string;
+    /** The bridge.json to read, or `false` to read none. Default: the
+     * desktop app's own (per-OS app-data folder). */
+    bridgeFile?: string | false;
+    /** Injected fetch (tests, proxies). Default: the global one. */
+    fetch?: typeof fetch;
+}
+/** A bridge or editor refusal: `code` is the bridge's (`ambiguous`,
+ * `noSuchEditor`, `readOnly`, `validation`, `fileNotFound`…). */
+declare class BridgeError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    /** The rest of the error body (e.g. `candidates` for `ambiguous`). */
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, opts?: {
+        code?: string;
+        status?: number;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+/** The desktop app's bridge.json path on this OS. */
+declare const bridgeFilePath: () => string;
+/** One editor, addressed by document id, file path or (unique) name. */
+interface EditorHandle {
+    /** How this handle addresses the editor. */
+    readonly ref: string;
+    /** Run one `linea_*` operation; resolves its result. */
+    call<T = unknown>(operation: string, args?: Record<string, unknown>): Promise<T>;
+    /**
+     * Run a `defineCommand` module inside the editor as ONE undo step —
+     * loops, reads and edits against the full Drawing API, one round trip.
+     * `inputs` / `params` answer the module's declared ones (the user is
+     * never asked).
+     */
+    runScript<T = unknown>(source: string, opts?: {
+        inputs?: readonly (readonly [number, number])[];
+        params?: Record<string, unknown>;
+    }): Promise<T>;
+    /** Close it like its window's x; a dirty desktop drawing is refused
+     * unless `discard`. */
+    close(opts?: {
+        discard?: boolean;
+    }): Promise<unknown>;
+}
+/** The running app: its editors and the operations they offer. */
+interface LineaBridge {
+    /** The bridge's address, e.g. http://127.0.0.1:7431. */
+    readonly url: string;
+    status(): Promise<BridgeStatus>;
+    /** The open editors. */
+    editors(): Promise<EditorInfo[]>;
+    /** The operations the bridge offers (name + description). */
+    tools(): Promise<{
+        name: string;
+        description?: string;
+    }[]>;
+    /** Open a `.linea` file in a window of its own (an absolute path, or one
+     * relative to the current directory); resolves once it has loaded. */
+    open(path: string): Promise<EditorInfo>;
+    /** A handle on one editor (id, path or unique name). Omitted: the only
+     * open editor — with several, calls fail as `ambiguous`. */
+    editor(ref?: string): EditorHandle;
+    /** One operation on an editor (`editor` as for `editor()`). */
+    call<T = unknown>(operation: string, args?: Record<string, unknown>, opts?: {
+        editor?: string;
+    }): Promise<T>;
+}
+/**
+ * Connect to the running Linea desktop app's bridge: reads its bridge.json
+ * (port, agent token), checks that it answers, and returns the client.
+ * Rejects with a BridgeError when nothing answers.
+ */
+declare const connectEditors: (opts?: BridgeOptions) => Promise<LineaBridge>;
+/** The client without the reachability check (the CLI's one-shot calls). */
+declare const createBridge: (opts?: BridgeOptions) => LineaBridge;
+
+export { BridgeError, type BridgeOptions, type BridgeStatus, DEFAULT_BRIDGE_PORT, type EditorHandle, type EditorInfo, type LineaBridge, bridgeFilePath, connectEditors, createBridge };

package/dist/bridge.js

@@ -0,0 +1,16 @@
+import {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+} from "./chunk-L2CWZAKW.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+};
+//# sourceMappingURL=bridge.js.map