npm - @kenkaiiii/gg-editor-premiere-panel - Versions diffs - 0.2.1 - Mend

@kenkaiiii/gg-editor-premiere-panel 0.2.1

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.

Files changed (39) hide show

package/LICENSE +21 -0
package/README.md +200 -0
package/dist/bin/cli.d.ts +3 -0
package/dist/bin/cli.d.ts.map +1 -0
package/dist/bin/cli.js +159 -0
package/dist/bin/cli.js.map +1 -0
package/dist/src/index.d.ts +4 -0
package/dist/src/index.d.ts.map +1 -0
package/dist/src/index.js +3 -0
package/dist/src/index.js.map +1 -0
package/dist/src/installer.d.ts +54 -0
package/dist/src/installer.d.ts.map +1 -0
package/dist/src/installer.js +166 -0
package/dist/src/installer.js.map +1 -0
package/dist/src/installer.test.d.ts +2 -0
package/dist/src/installer.test.d.ts.map +1 -0
package/dist/src/installer.test.js +68 -0
package/dist/src/installer.test.js.map +1 -0
package/dist/src/paths.d.ts +30 -0
package/dist/src/paths.d.ts.map +1 -0
package/dist/src/paths.js +60 -0
package/dist/src/paths.js.map +1 -0
package/dist/src/paths.test.d.ts +2 -0
package/dist/src/paths.test.d.ts.map +1 -0
package/dist/src/paths.test.js +47 -0
package/dist/src/paths.test.js.map +1 -0
package/package.json +42 -0
package/panel/.debug +15 -0
package/panel/CSXS/manifest.xml +60 -0
package/panel/index.html +28 -0
package/panel/jsx/runtime.jsx +163 -0
package/panel/lib/cs-interface.js +31 -0
package/panel/lib/server.js +161 -0
package/panel-uxp/commands/consts.js +43 -0
package/panel-uxp/commands/index.js +401 -0
package/panel-uxp/commands/utils.js +115 -0
package/panel-uxp/index.html +107 -0
package/panel-uxp/main.js +264 -0
package/panel-uxp/manifest.json +46 -0

package/panel-uxp/commands/utils.js ADDED Viewed

@@ -0,0 +1,115 @@
+/* eslint-disable */
+/**
+ * Utility helpers shared across the Premiere UXP command handlers.
+ *
+ * Verified against:
+ *   - mikechambers/adb-mcp (uxp/pr/commands/utils.js)
+ *   - AdobeDocs/uxp-premiere-pro-samples
+ *
+ * Async-everywhere: pretty much every getter on the Premiere DOM is async.
+ */
+const ppro = require("premierepro");
+const { TICKS_PER_SECOND } = require("./consts.js");
+/** Active project, throwing a clear message if Premiere has nothing open. */
+async function getActiveProject() {
+  const project = await ppro.Project.getActiveProject();
+  if (!project) throw new Error("No project open in Premiere.");
+  return project;
+}
+/** Active sequence, throwing a clear message if there is none. */
+async function getActiveSequence() {
+  const project = await getActiveProject();
+  const seq = await project.getActiveSequence();
+  if (!seq) throw new Error("No active sequence in Premiere.");
+  return { project, sequence: seq };
+}
+/**
+ * Recursively walk the project bins looking for a project item by name.
+ * Returns null when not found (caller can decide whether to throw).
+ */
+async function findProjectItem(parent, name) {
+  const items = await parent.getItems();
+  for (const item of items) {
+    if (item.name === name) return item;
+  }
+  for (const item of items) {
+    const folder = ppro.FolderItem.cast(item);
+    if (folder) {
+      const found = await findProjectItem(folder, name);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+/** Search the entire project tree from root for an item by name. */
+async function findProjectItemByName(project, name) {
+  const root = await project.getRootItem();
+  return findProjectItem(root, name);
+}
+/**
+ * Compute frames-per-second for a sequence. Premiere stores `timebase` as
+ * ticks per frame; fps = TICKS_PER_SECOND / timebase.
+ */
+async function fpsOf(sequence) {
+  const tb = await sequence.getTimebase();
+  if (!tb) return 30;
+  return TICKS_PER_SECOND / tb;
+}
+/** Convert a frame count + sequence into a tick count. */
+async function framesToTicks(frames, sequence) {
+  const tb = await sequence.getTimebase();
+  return Math.round(frames * tb);
+}
+/** Convert a tick count + sequence into a (rounded) frame number. */
+async function ticksToFrames(ticks, sequence) {
+  const tb = await sequence.getTimebase();
+  if (!tb) return 0;
+  return Math.round(ticks / tb);
+}
+/** Convert seconds to ticks (used when adding markers etc). */
+function secondsToTicks(seconds) {
+  return Math.round(seconds * TICKS_PER_SECOND);
+}
+/**
+ * Wrap a synchronous "build action list" callback in Premiere's required
+ * lockedAccess + executeTransaction envelope. The callback receives no
+ * arguments and must return an array of action objects to add to the
+ * compound transaction.
+ *
+ * Errors inside the transaction are re-thrown with context so the caller's
+ * try/catch sees a readable message.
+ */
+function withTransaction(project, getActions) {
+  try {
+    project.lockedAccess(() => {
+      project.executeTransaction((compoundAction) => {
+        const actions = getActions();
+        for (const a of actions) compoundAction.addAction(a);
+      });
+    });
+  } catch (e) {
+    throw new Error("Premiere transaction failed: " + (e && e.message ? e.message : e));
+  }
+}
+module.exports = {
+  getActiveProject,
+  getActiveSequence,
+  findProjectItem,
+  findProjectItemByName,
+  fpsOf,
+  framesToTicks,
+  ticksToFrames,
+  secondsToTicks,
+  withTransaction,
+};

package/panel-uxp/index.html ADDED Viewed

@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>GG Editor</title>
+    <style>
+      :root {
+        color-scheme: dark;
+      }
+      body {
+        font: 12px -apple-system, "Segoe UI", sans-serif;
+        margin: 0;
+        padding: 12px;
+        background: #1f2937;
+        color: #e5e7eb;
+      }
+      h1 {
+        font-size: 13px;
+        font-weight: 700;
+        color: #60a5fa;
+        margin: 0 0 10px;
+      }
+      .row {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 4px 0;
+        border-bottom: 1px solid #374151;
+      }
+      .row:last-child {
+        border-bottom: none;
+      }
+      .muted {
+        color: #9ca3af;
+      }
+      .pill {
+        background: #374151;
+        padding: 2px 8px;
+        border-radius: 3px;
+        font-size: 11px;
+      }
+      .pill.ok {
+        background: #064e3b;
+        color: #a7f3d0;
+      }
+      .pill.err {
+        background: #7f1d1d;
+        color: #fecaca;
+      }
+      .controls {
+        margin-top: 10px;
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+      }
+      .field {
+        display: flex;
+        gap: 6px;
+        align-items: center;
+      }
+      input[type="number"] {
+        flex: 1;
+        background: #111827;
+        color: #e5e7eb;
+        border: 1px solid #374151;
+        border-radius: 3px;
+        padding: 4px 6px;
+        font: inherit;
+      }
+      label {
+        display: flex;
+        gap: 6px;
+        align-items: center;
+      }
+      code {
+        background: #111827;
+        padding: 1px 4px;
+        border-radius: 2px;
+        font-family: ui-monospace, monospace;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>GG Editor (UXP)</h1>
+    <div class="row"><span class="muted">Status</span><span id="status" class="pill">idle</span></div>
+    <div class="row"><span class="muted">Connected to</span><span id="endpoint" class="pill">—</span></div>
+    <div class="row"><span class="muted">Requests</span><span id="reqs">0</span></div>
+    <div class="row"><span class="muted">Last error</span><span id="lastErr" class="muted">—</span></div>
+    <div class="controls">
+      <div class="field">
+        <span class="muted">Port</span>
+        <input id="port" type="number" min="1024" max="65535" />
+        <sp-button id="connectBtn" size="s" variant="primary">Connect</sp-button>
+      </div>
+      <label>
+        <sp-checkbox id="autoConnect"></sp-checkbox>
+        <span>Connect on launch</span>
+      </label>
+    </div>
+    <div class="row" style="margin-top: 10px"><span class="muted">CLI</span><code>ggeditor --host premiere</code></div>
+    <script src="main.js"></script>
+  </body>
+</html>

package/panel-uxp/main.js ADDED Viewed

@@ -0,0 +1,264 @@
+/* eslint-disable */
+/**
+ * GG Editor UXP plugin entrypoint.
+ *
+ * UXP plugins cannot listen on TCP ports. So instead of being an HTTP
+ * server like the CEP panel, this plugin is a **WebSocket client**: it
+ * dials out to the ggeditor CLI's localhost WS server, sends a hello
+ * frame, and then handles RPC requests on the same connection.
+ *
+ * Wire protocol (matches PremiereWsBridge in @kenkaiiii/gg-editor):
+ *
+ *   plugin → server (once, on connect):
+ *     { kind: "hello", product, panelKind: "uxp", version }
+ *
+ *   server → plugin:
+ *     { id: "1", method: "get_timeline", params: {} }
+ *
+ *   plugin → server:
+ *     { id: "1", ok: true, result: ... }
+ *     { id: "1", ok: false, error: "..." }
+ *
+ * Reconnection uses exponential backoff capped at 5s — handles the case
+ * where the user starts ggeditor *after* opening Premiere.
+ */
+const { handle } = require("./commands/index.js");
+const PRODUCT = "gg-editor-premiere-panel";
+const VERSION = "0.2.0";
+const DEFAULT_PORT = 7437;
+const RECONNECT_INITIAL_MS = 500;
+const RECONNECT_MAX_MS = 5000;
+// ── Persisted prefs (UXP supports localStorage) ─────────────
+function getPort() {
+  try {
+    const stored = localStorage.getItem("gg.port");
+    const n = stored ? parseInt(stored, 10) : NaN;
+    if (Number.isFinite(n) && n > 0 && n < 65536) return n;
+  } catch (_) {}
+  return DEFAULT_PORT;
+}
+function setPort(n) {
+  try {
+    localStorage.setItem("gg.port", String(n));
+  } catch (_) {}
+}
+function getAutoConnect() {
+  try {
+    return localStorage.getItem("gg.autoConnect") === "1";
+  } catch (_) {
+    return false;
+  }
+}
+function setAutoConnect(b) {
+  try {
+    localStorage.setItem("gg.autoConnect", b ? "1" : "0");
+  } catch (_) {}
+}
+// ── UI plumbing ─────────────────────────────────────────────
+let reqCount = 0;
+function $(id) {
+  return document.getElementById(id);
+}
+function setStatus(kind, label) {
+  const el = $("status");
+  if (!el) return;
+  el.textContent = label;
+  el.className = "pill " + (kind || "");
+}
+function setEndpoint(text) {
+  const el = $("endpoint");
+  if (el) el.textContent = text;
+}
+function bumpReqs() {
+  reqCount += 1;
+  const el = $("reqs");
+  if (el) el.textContent = String(reqCount);
+}
+function setLastErr(msg) {
+  const el = $("lastErr");
+  if (!el) return;
+  el.textContent = msg || "—";
+  el.className = msg ? "err" : "muted";
+}
+function setConnectButtonLabel(label) {
+  const el = $("connectBtn");
+  if (el) el.textContent = label;
+}
+// ── WS client ───────────────────────────────────────────────
+let socket = null;
+let reconnectDelay = RECONNECT_INITIAL_MS;
+let reconnectTimer = null;
+let manuallyDisconnected = false;
+let currentPort = DEFAULT_PORT;
+function disconnect() {
+  manuallyDisconnected = true;
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  if (socket) {
+    try {
+      socket.close(1000, "user disconnected");
+    } catch (_) {}
+    socket = null;
+  }
+  setStatus("", "idle");
+  setEndpoint("—");
+  setConnectButtonLabel("Connect");
+}
+function connect() {
+  manuallyDisconnected = false;
+  if (socket && (socket.readyState === 0 || socket.readyState === 1)) {
+    return; // already connecting / connected
+  }
+  currentPort = getPort();
+  const url = "ws://127.0.0.1:" + currentPort;
+  setStatus("", "connecting…");
+  setEndpoint(url);
+  setConnectButtonLabel("Disconnect");
+  let ws;
+  try {
+    ws = new WebSocket(url);
+  } catch (e) {
+    setStatus("err", "open failed");
+    setLastErr(String(e && e.message ? e.message : e));
+    scheduleReconnect();
+    return;
+  }
+  socket = ws;
+  ws.addEventListener("open", () => {
+    reconnectDelay = RECONNECT_INITIAL_MS;
+    setStatus("ok", "connected");
+    setLastErr("");
+    try {
+      ws.send(
+        JSON.stringify({
+          kind: "hello",
+          product: PRODUCT,
+          panelKind: "uxp",
+          version: VERSION,
+        }),
+      );
+    } catch (e) {
+      setLastErr("hello send failed: " + e);
+    }
+  });
+  ws.addEventListener("message", async (ev) => {
+    let msg;
+    try {
+      msg = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+    } catch (_) {
+      return;
+    }
+    if (!msg || typeof msg.id !== "string" || typeof msg.method !== "string") return;
+    bumpReqs();
+    let response;
+    try {
+      const result = await handle(msg.method, msg.params || {});
+      response = { id: msg.id, ok: true, result: result === undefined ? null : result };
+    } catch (e) {
+      const errMsg = e && e.message ? String(e.message) : String(e);
+      setLastErr(errMsg);
+      response = { id: msg.id, ok: false, error: errMsg };
+    }
+    try {
+      if (ws.readyState === 1) ws.send(JSON.stringify(response));
+    } catch (e) {
+      setLastErr("send reply failed: " + e);
+    }
+  });
+  ws.addEventListener("close", () => {
+    if (socket === ws) socket = null;
+    if (manuallyDisconnected) return;
+    setStatus("err", "disconnected");
+    scheduleReconnect();
+  });
+  ws.addEventListener("error", (ev) => {
+    setLastErr("ws error");
+  });
+}
+function scheduleReconnect() {
+  if (manuallyDisconnected) return;
+  if (reconnectTimer) return;
+  setConnectButtonLabel("Cancel");
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    if (manuallyDisconnected) return;
+    reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+    connect();
+  }, reconnectDelay);
+}
+// ── Wire up UI on panel show ────────────────────────────────
+function init(rootNode) {
+  const portEl = $("port");
+  const autoEl = $("autoConnect");
+  const btnEl = $("connectBtn");
+  if (portEl) {
+    portEl.value = String(getPort());
+    portEl.addEventListener("change", () => {
+      const n = parseInt(portEl.value, 10);
+      if (Number.isFinite(n) && n > 0 && n < 65536) setPort(n);
+    });
+  }
+  if (autoEl) {
+    if (getAutoConnect()) autoEl.setAttribute("checked", "");
+    autoEl.addEventListener("change", () => {
+      setAutoConnect(autoEl.checked || autoEl.hasAttribute("checked"));
+    });
+  }
+  if (btnEl) {
+    btnEl.addEventListener("click", () => {
+      if (socket && socket.readyState === 1) {
+        disconnect();
+      } else {
+        connect();
+      }
+    });
+  }
+  if (getAutoConnect()) {
+    connect();
+  }
+}
+// ── UXP entrypoint registration ─────────────────────────────
+const { entrypoints } = require("uxp");
+entrypoints.setup({
+  panels: {
+    "ggeditor.panel": {
+      show(node) {
+        init(node);
+      },
+    },
+  },
+});

package/panel-uxp/manifest.json ADDED Viewed

@@ -0,0 +1,46 @@
+{
+  "id": "com.kenkaiiii.gg-editor-premiere-panel.uxp",
+  "name": "GG Editor",
+  "version": "0.2.0",
+  "main": "index.html",
+  "manifestVersion": 5,
+  "host": [
+    {
+      "app": "premierepro",
+      "minVersion": "25.6.0"
+    }
+  ],
+  "entrypoints": [
+    {
+      "type": "panel",
+      "id": "ggeditor.panel",
+      "label": {
+        "default": "GG Editor"
+      },
+      "minimumSize": { "width": 280, "height": 220 },
+      "preferredDockedSize": { "width": 320, "height": 260 },
+      "preferredFloatingSize": { "width": 360, "height": 280 }
+    }
+  ],
+  "requiredPermissions": {
+    "network": {
+      "domains": [
+        "ws://127.0.0.1:7437",
+        "ws://127.0.0.1:7438",
+        "ws://127.0.0.1:7439",
+        "ws://127.0.0.1:7440",
+        "ws://127.0.0.1:7441",
+        "ws://127.0.0.1:7442",
+        "ws://127.0.0.1:7443",
+        "ws://localhost:7437",
+        "ws://localhost:7438",
+        "ws://localhost:7439",
+        "ws://localhost:7440",
+        "ws://localhost:7441",
+        "ws://localhost:7442",
+        "ws://localhost:7443"
+      ]
+    }
+  },
+  "icons": []
+}