playcanvas-agent-bridge-cli 0.2.0
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.
- package/LICENSE +21 -0
- package/README.md +162 -0
- package/README.zh-CN.md +162 -0
- package/dist/cli.js +702 -0
- package/dist/config.js +94 -0
- package/dist/daemon/server.js +204 -0
- package/dist/daemon/target-registry.js +102 -0
- package/dist/shared/protocol.js +21 -0
- package/dist/snippets.js +613 -0
- package/extension/config.example.json +5 -0
- package/extension/isolated.js +224 -0
- package/extension/main.js +288 -0
- package/extension/manifest.json +39 -0
- package/extension/popup.html +47 -0
- package/extension/popup.js +26 -0
- package/extension/service-worker.js +33 -0
- package/package.json +42 -0
- package/skills/claude/playcanvas-agent-bridge-cli/SKILL.md +41 -0
- package/skills/codex/playcanvas-agent-bridge-cli/SKILL.md +150 -0
- package/skills/codex/playcanvas-agent-bridge-cli/agents/openai.yaml +4 -0
- package/skills/cursor/playcanvas-agent-bridge-cli.mdc +37 -0
- package/skills/windsurf/playcanvas-agent-bridge-cli.md +34 -0
package/dist/config.js
ADDED
|
@@ -0,0 +1,94 @@
|
|
|
1
|
+
import { randomBytes } from "node:crypto";
|
|
2
|
+
import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
|
|
3
|
+
import { existsSync } from "node:fs";
|
|
4
|
+
import { homedir } from "node:os";
|
|
5
|
+
import { dirname, join, resolve } from "node:path";
|
|
6
|
+
import { fileURLToPath } from "node:url";
|
|
7
|
+
export const VERSION = "0.2.0";
|
|
8
|
+
export const DEFAULT_HOST = "127.0.0.1";
|
|
9
|
+
export const DEFAULT_PORT = 17329;
|
|
10
|
+
export const CONFIG_DIR = join(homedir(), ".pcbridge");
|
|
11
|
+
export const SESSION_FILE = join(CONFIG_DIR, "session.json");
|
|
12
|
+
export const EXTENSION_INSTALL_DIR = join(CONFIG_DIR, "extension");
|
|
13
|
+
export async function readOrCreateSession() {
|
|
14
|
+
await mkdir(CONFIG_DIR, { recursive: true });
|
|
15
|
+
try {
|
|
16
|
+
const parsed = JSON.parse(await readFile(SESSION_FILE, "utf8"));
|
|
17
|
+
if (typeof parsed.token === "string" && parsed.token.length >= 24) {
|
|
18
|
+
return {
|
|
19
|
+
token: parsed.token,
|
|
20
|
+
port: Number(parsed.port || DEFAULT_PORT),
|
|
21
|
+
createdAt: parsed.createdAt || new Date().toISOString(),
|
|
22
|
+
};
|
|
23
|
+
}
|
|
24
|
+
}
|
|
25
|
+
catch {
|
|
26
|
+
// Create a new local token below.
|
|
27
|
+
}
|
|
28
|
+
const session = {
|
|
29
|
+
token: randomBytes(32).toString("hex"),
|
|
30
|
+
port: DEFAULT_PORT,
|
|
31
|
+
createdAt: new Date().toISOString(),
|
|
32
|
+
};
|
|
33
|
+
await writeFile(SESSION_FILE, `${JSON.stringify(session, null, 2)}\n`, {
|
|
34
|
+
mode: 0o600,
|
|
35
|
+
});
|
|
36
|
+
return session;
|
|
37
|
+
}
|
|
38
|
+
export async function readSessionIfExists() {
|
|
39
|
+
try {
|
|
40
|
+
const parsed = JSON.parse(await readFile(SESSION_FILE, "utf8"));
|
|
41
|
+
if (typeof parsed.token === "string") {
|
|
42
|
+
return {
|
|
43
|
+
token: parsed.token,
|
|
44
|
+
port: Number(parsed.port || DEFAULT_PORT),
|
|
45
|
+
createdAt: parsed.createdAt || "",
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
}
|
|
49
|
+
catch {
|
|
50
|
+
return null;
|
|
51
|
+
}
|
|
52
|
+
return null;
|
|
53
|
+
}
|
|
54
|
+
export async function writeSession(session) {
|
|
55
|
+
await mkdir(CONFIG_DIR, { recursive: true });
|
|
56
|
+
await writeFile(SESSION_FILE, `${JSON.stringify(session, null, 2)}\n`, {
|
|
57
|
+
mode: 0o600,
|
|
58
|
+
});
|
|
59
|
+
}
|
|
60
|
+
export async function findPackageRoot() {
|
|
61
|
+
const here = dirname(fileURLToPath(import.meta.url));
|
|
62
|
+
const candidates = [
|
|
63
|
+
resolve(here, ".."),
|
|
64
|
+
resolve(here, "..", ".."),
|
|
65
|
+
process.cwd(),
|
|
66
|
+
];
|
|
67
|
+
for (const candidate of candidates) {
|
|
68
|
+
if (existsSync(join(candidate, "package.json")) &&
|
|
69
|
+
existsSync(join(candidate, "extension"))) {
|
|
70
|
+
return candidate;
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
throw new Error("Cannot locate package root with bundled extension directory.");
|
|
74
|
+
}
|
|
75
|
+
export async function copyDir(source, destination, options = {}) {
|
|
76
|
+
if (options.clean) {
|
|
77
|
+
await rm(destination, { force: true, recursive: true });
|
|
78
|
+
}
|
|
79
|
+
await mkdir(destination, { recursive: true });
|
|
80
|
+
const entries = await readdir(source);
|
|
81
|
+
for (const entry of entries) {
|
|
82
|
+
if (options.ignore?.has(entry))
|
|
83
|
+
continue;
|
|
84
|
+
const from = join(source, entry);
|
|
85
|
+
const to = join(destination, entry);
|
|
86
|
+
const info = await stat(from);
|
|
87
|
+
if (info.isDirectory()) {
|
|
88
|
+
await copyDir(from, to, { ignore: options.ignore });
|
|
89
|
+
}
|
|
90
|
+
else if (info.isFile()) {
|
|
91
|
+
await copyFile(from, to);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
}
|
|
@@ -0,0 +1,204 @@
|
|
|
1
|
+
import http from "node:http";
|
|
2
|
+
import { randomUUID } from "node:crypto";
|
|
3
|
+
import { WebSocketServer } from "ws";
|
|
4
|
+
import { DEFAULT_HOST, DEFAULT_PORT, VERSION } from "../config.js";
|
|
5
|
+
import { TargetRegistry } from "./target-registry.js";
|
|
6
|
+
import { fail, normalizeError, ok, } from "../shared/protocol.js";
|
|
7
|
+
function readBody(req) {
|
|
8
|
+
return new Promise((resolve, reject) => {
|
|
9
|
+
let text = "";
|
|
10
|
+
req.setEncoding("utf8");
|
|
11
|
+
req.on("data", (chunk) => {
|
|
12
|
+
text += chunk;
|
|
13
|
+
});
|
|
14
|
+
req.on("end", () => {
|
|
15
|
+
if (!text) {
|
|
16
|
+
resolve(null);
|
|
17
|
+
return;
|
|
18
|
+
}
|
|
19
|
+
try {
|
|
20
|
+
resolve(JSON.parse(text));
|
|
21
|
+
}
|
|
22
|
+
catch (error) {
|
|
23
|
+
reject(error);
|
|
24
|
+
}
|
|
25
|
+
});
|
|
26
|
+
req.on("error", reject);
|
|
27
|
+
});
|
|
28
|
+
}
|
|
29
|
+
function writeJson(res, status, body) {
|
|
30
|
+
res.writeHead(status, {
|
|
31
|
+
"Content-Type": "application/json; charset=utf-8",
|
|
32
|
+
"Cache-Control": "no-store",
|
|
33
|
+
});
|
|
34
|
+
res.end(`${JSON.stringify(body)}\n`);
|
|
35
|
+
}
|
|
36
|
+
function isJsonObject(value) {
|
|
37
|
+
return Boolean(value && typeof value === "object" && !Array.isArray(value));
|
|
38
|
+
}
|
|
39
|
+
export function createDaemonServer(options) {
|
|
40
|
+
const host = options.host || DEFAULT_HOST;
|
|
41
|
+
const port = Number(options.port || DEFAULT_PORT);
|
|
42
|
+
const registry = new TargetRegistry();
|
|
43
|
+
const pending = new Map();
|
|
44
|
+
const log = options.log || (() => undefined);
|
|
45
|
+
function requireToken(req) {
|
|
46
|
+
return req.headers["x-pcbridge-token"] === options.token;
|
|
47
|
+
}
|
|
48
|
+
async function sendToTarget(request) {
|
|
49
|
+
if (!request.method) {
|
|
50
|
+
return fail("INVALID_REQUEST", "RPC method is required.");
|
|
51
|
+
}
|
|
52
|
+
const resolved = registry.resolve(request.target || "current");
|
|
53
|
+
if (!resolved.ok) {
|
|
54
|
+
return fail(resolved.code, resolved.message, undefined, (resolved.candidates || []));
|
|
55
|
+
}
|
|
56
|
+
const timeoutMs = Math.min(Math.max(Number(request.timeoutMs || 15000), 1000), 120000);
|
|
57
|
+
const id = `req_${randomUUID()}`;
|
|
58
|
+
const message = {
|
|
59
|
+
id,
|
|
60
|
+
type: "request",
|
|
61
|
+
method: request.method,
|
|
62
|
+
params: request.params,
|
|
63
|
+
timeoutMs,
|
|
64
|
+
};
|
|
65
|
+
return new Promise((resolve) => {
|
|
66
|
+
const timer = setTimeout(() => {
|
|
67
|
+
pending.delete(id);
|
|
68
|
+
resolve(fail("REQUEST_TIMEOUT", `Timed out after ${timeoutMs}ms.`, {
|
|
69
|
+
target: resolved.target.info.id,
|
|
70
|
+
}));
|
|
71
|
+
}, timeoutMs + 250);
|
|
72
|
+
pending.set(id, {
|
|
73
|
+
resolve,
|
|
74
|
+
timer,
|
|
75
|
+
startedAt: Date.now(),
|
|
76
|
+
targetId: resolved.target.info.id,
|
|
77
|
+
});
|
|
78
|
+
resolved.target.ws.send(JSON.stringify(message), (error) => {
|
|
79
|
+
if (error) {
|
|
80
|
+
clearTimeout(timer);
|
|
81
|
+
pending.delete(id);
|
|
82
|
+
resolve(fail("WEBSOCKET_SEND_FAILED", error.message, {
|
|
83
|
+
target: resolved.target.info.id,
|
|
84
|
+
}));
|
|
85
|
+
}
|
|
86
|
+
});
|
|
87
|
+
});
|
|
88
|
+
}
|
|
89
|
+
const server = http.createServer(async (req, res) => {
|
|
90
|
+
try {
|
|
91
|
+
const url = new URL(req.url || "/", `http://${req.headers.host || `${host}:${port}`}`);
|
|
92
|
+
if (url.pathname === "/health" && req.method === "GET") {
|
|
93
|
+
if (!requireToken(req)) {
|
|
94
|
+
writeJson(res, 403, fail("BAD_TOKEN", "Invalid pcbridge token."));
|
|
95
|
+
return;
|
|
96
|
+
}
|
|
97
|
+
writeJson(res, 200, ok({
|
|
98
|
+
version: VERSION,
|
|
99
|
+
host,
|
|
100
|
+
port,
|
|
101
|
+
targetCount: registry.list().filter((target) => target.connected).length,
|
|
102
|
+
}));
|
|
103
|
+
return;
|
|
104
|
+
}
|
|
105
|
+
if (url.pathname === "/targets" && req.method === "GET") {
|
|
106
|
+
if (!requireToken(req)) {
|
|
107
|
+
writeJson(res, 403, fail("BAD_TOKEN", "Invalid pcbridge token."));
|
|
108
|
+
return;
|
|
109
|
+
}
|
|
110
|
+
writeJson(res, 200, ok(registry.list()));
|
|
111
|
+
return;
|
|
112
|
+
}
|
|
113
|
+
if (url.pathname === "/rpc" && req.method === "POST") {
|
|
114
|
+
if (!requireToken(req)) {
|
|
115
|
+
writeJson(res, 403, fail("BAD_TOKEN", "Invalid pcbridge token."));
|
|
116
|
+
return;
|
|
117
|
+
}
|
|
118
|
+
const body = await readBody(req);
|
|
119
|
+
if (!isJsonObject(body)) {
|
|
120
|
+
writeJson(res, 400, fail("INVALID_REQUEST", "JSON body is required."));
|
|
121
|
+
return;
|
|
122
|
+
}
|
|
123
|
+
const response = await sendToTarget(body);
|
|
124
|
+
writeJson(res, response.ok ? 200 : 400, response);
|
|
125
|
+
return;
|
|
126
|
+
}
|
|
127
|
+
writeJson(res, 404, fail("NOT_FOUND", `Unknown endpoint ${url.pathname}.`));
|
|
128
|
+
}
|
|
129
|
+
catch (error) {
|
|
130
|
+
writeJson(res, 500, fail("DAEMON_ERROR", String(error)));
|
|
131
|
+
}
|
|
132
|
+
});
|
|
133
|
+
const wss = new WebSocketServer({ noServer: true });
|
|
134
|
+
server.on("upgrade", (req, socket, head) => {
|
|
135
|
+
const url = new URL(req.url || "/", `http://${req.headers.host || `${host}:${port}`}`);
|
|
136
|
+
if (url.pathname !== "/extension" || url.searchParams.get("token") !== options.token) {
|
|
137
|
+
socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
|
|
138
|
+
socket.destroy();
|
|
139
|
+
return;
|
|
140
|
+
}
|
|
141
|
+
wss.handleUpgrade(req, socket, head, (ws) => {
|
|
142
|
+
wss.emit("connection", ws, req);
|
|
143
|
+
});
|
|
144
|
+
});
|
|
145
|
+
wss.on("connection", (ws) => {
|
|
146
|
+
log("extension connected");
|
|
147
|
+
ws.on("message", (raw) => {
|
|
148
|
+
try {
|
|
149
|
+
const message = JSON.parse(raw.toString());
|
|
150
|
+
if (message.type === "target:update" && message.target?.clientId) {
|
|
151
|
+
const info = registry.upsert(message.target, ws);
|
|
152
|
+
log(`target ${info.id} ready=${info.ready} url=${info.url}`);
|
|
153
|
+
return;
|
|
154
|
+
}
|
|
155
|
+
if (message.type === "response" && message.id) {
|
|
156
|
+
const waiter = pending.get(message.id);
|
|
157
|
+
if (!waiter)
|
|
158
|
+
return;
|
|
159
|
+
pending.delete(message.id);
|
|
160
|
+
clearTimeout(waiter.timer);
|
|
161
|
+
const durationMs = Date.now() - waiter.startedAt;
|
|
162
|
+
if (message.ok) {
|
|
163
|
+
waiter.resolve(ok((message.data ?? null), {
|
|
164
|
+
...(message.meta || {}),
|
|
165
|
+
target: waiter.targetId,
|
|
166
|
+
durationMs,
|
|
167
|
+
}));
|
|
168
|
+
}
|
|
169
|
+
else {
|
|
170
|
+
const error = normalizeError(message.error);
|
|
171
|
+
waiter.resolve(fail(error.code, error.message, {
|
|
172
|
+
...(message.meta || {}),
|
|
173
|
+
target: waiter.targetId,
|
|
174
|
+
durationMs,
|
|
175
|
+
}));
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
catch (error) {
|
|
180
|
+
log(`bad websocket message: ${String(error)}`);
|
|
181
|
+
}
|
|
182
|
+
});
|
|
183
|
+
ws.on("close", () => {
|
|
184
|
+
registry.markDisconnected(ws);
|
|
185
|
+
log("extension disconnected");
|
|
186
|
+
});
|
|
187
|
+
});
|
|
188
|
+
return {
|
|
189
|
+
host,
|
|
190
|
+
port,
|
|
191
|
+
registry,
|
|
192
|
+
listen: () => new Promise((resolve, reject) => {
|
|
193
|
+
server.once("error", reject);
|
|
194
|
+
server.listen(port, host, () => {
|
|
195
|
+
server.off("error", reject);
|
|
196
|
+
resolve();
|
|
197
|
+
});
|
|
198
|
+
}),
|
|
199
|
+
close: () => new Promise((resolve) => {
|
|
200
|
+
wss.close();
|
|
201
|
+
server.close(() => resolve());
|
|
202
|
+
}),
|
|
203
|
+
};
|
|
204
|
+
}
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
export class TargetRegistry {
|
|
2
|
+
#targets = new Map();
|
|
3
|
+
#clientToTarget = new Map();
|
|
4
|
+
upsert(info, ws) {
|
|
5
|
+
const targetId = info.tabId !== undefined ? `tab:${info.tabId}` : `client:${info.clientId}`;
|
|
6
|
+
const now = new Date().toISOString();
|
|
7
|
+
const existing = this.#targets.get(targetId)?.info;
|
|
8
|
+
const next = {
|
|
9
|
+
id: targetId,
|
|
10
|
+
clientId: info.clientId,
|
|
11
|
+
tabId: info.tabId,
|
|
12
|
+
windowId: info.windowId,
|
|
13
|
+
url: info.url || existing?.url || "",
|
|
14
|
+
title: info.title || existing?.title,
|
|
15
|
+
projectId: info.projectId || existing?.projectId,
|
|
16
|
+
sceneId: info.sceneId || existing?.sceneId,
|
|
17
|
+
branchId: info.branchId || existing?.branchId,
|
|
18
|
+
ready: Boolean(info.ready),
|
|
19
|
+
connected: true,
|
|
20
|
+
lastSeen: now,
|
|
21
|
+
};
|
|
22
|
+
this.#targets.set(targetId, { info: next, ws });
|
|
23
|
+
this.#clientToTarget.set(info.clientId, targetId);
|
|
24
|
+
return next;
|
|
25
|
+
}
|
|
26
|
+
markDisconnected(ws) {
|
|
27
|
+
for (const [id, connection] of this.#targets.entries()) {
|
|
28
|
+
if (connection.ws === ws) {
|
|
29
|
+
connection.info.connected = false;
|
|
30
|
+
connection.info.ready = false;
|
|
31
|
+
connection.info.lastSeen = new Date().toISOString();
|
|
32
|
+
this.#targets.set(id, connection);
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
list() {
|
|
37
|
+
return Array.from(this.#targets.values())
|
|
38
|
+
.map((entry) => entry.info)
|
|
39
|
+
.sort((left, right) => right.lastSeen.localeCompare(left.lastSeen));
|
|
40
|
+
}
|
|
41
|
+
resolve(selector = "current") {
|
|
42
|
+
const targets = Array.from(this.#targets.values()).filter((target) => target.info.connected);
|
|
43
|
+
const readyTargets = targets.filter((target) => target.info.ready);
|
|
44
|
+
if (selector === "current") {
|
|
45
|
+
const target = readyTargets.sort((left, right) => right.info.lastSeen.localeCompare(left.info.lastSeen))[0];
|
|
46
|
+
if (!target) {
|
|
47
|
+
return {
|
|
48
|
+
ok: false,
|
|
49
|
+
code: "NO_READY_TARGET",
|
|
50
|
+
message: "No ready PlayCanvas Editor target is connected.",
|
|
51
|
+
candidates: this.list(),
|
|
52
|
+
};
|
|
53
|
+
}
|
|
54
|
+
return { ok: true, target };
|
|
55
|
+
}
|
|
56
|
+
if (selector.startsWith("client:")) {
|
|
57
|
+
const id = this.#clientToTarget.get(selector.slice("client:".length));
|
|
58
|
+
const target = id ? this.#targets.get(id) : undefined;
|
|
59
|
+
if (target?.info.connected)
|
|
60
|
+
return { ok: true, target };
|
|
61
|
+
return {
|
|
62
|
+
ok: false,
|
|
63
|
+
code: "TARGET_NOT_FOUND",
|
|
64
|
+
message: `No connected target matches ${selector}.`,
|
|
65
|
+
candidates: this.list(),
|
|
66
|
+
};
|
|
67
|
+
}
|
|
68
|
+
if (selector.startsWith("tab:")) {
|
|
69
|
+
const target = this.#targets.get(selector);
|
|
70
|
+
if (target?.info.connected)
|
|
71
|
+
return { ok: true, target };
|
|
72
|
+
return {
|
|
73
|
+
ok: false,
|
|
74
|
+
code: "TARGET_NOT_FOUND",
|
|
75
|
+
message: `No connected target matches ${selector}.`,
|
|
76
|
+
candidates: this.list(),
|
|
77
|
+
};
|
|
78
|
+
}
|
|
79
|
+
const [kind, value] = selector.split(":", 2);
|
|
80
|
+
if ((kind === "scene" || kind === "project") && value) {
|
|
81
|
+
const matches = targets.filter((target) => kind === "scene"
|
|
82
|
+
? target.info.sceneId === value
|
|
83
|
+
: target.info.projectId === value);
|
|
84
|
+
if (matches.length === 1)
|
|
85
|
+
return { ok: true, target: matches[0] };
|
|
86
|
+
if (matches.length > 1) {
|
|
87
|
+
return {
|
|
88
|
+
ok: false,
|
|
89
|
+
code: "AMBIGUOUS_TARGET",
|
|
90
|
+
message: `${selector} matches multiple connected targets.`,
|
|
91
|
+
candidates: matches.map((target) => target.info),
|
|
92
|
+
};
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
return {
|
|
96
|
+
ok: false,
|
|
97
|
+
code: "TARGET_NOT_FOUND",
|
|
98
|
+
message: `No connected target matches ${selector}.`,
|
|
99
|
+
candidates: this.list(),
|
|
100
|
+
};
|
|
101
|
+
}
|
|
102
|
+
}
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
export function ok(data, meta) {
|
|
2
|
+
return meta ? { ok: true, data, meta } : { ok: true, data };
|
|
3
|
+
}
|
|
4
|
+
export function fail(code, message, meta, details) {
|
|
5
|
+
const error = details
|
|
6
|
+
? { code, message, details }
|
|
7
|
+
: { code, message };
|
|
8
|
+
return meta ? { ok: false, error, meta } : { ok: false, error };
|
|
9
|
+
}
|
|
10
|
+
export function normalizeError(value) {
|
|
11
|
+
if (value && typeof value === "object") {
|
|
12
|
+
const candidate = value;
|
|
13
|
+
if (typeof candidate.code === "string" && typeof candidate.message === "string") {
|
|
14
|
+
return { code: candidate.code, message: candidate.message };
|
|
15
|
+
}
|
|
16
|
+
if (typeof candidate.message === "string") {
|
|
17
|
+
return { code: "PAGE_ERROR", message: candidate.message };
|
|
18
|
+
}
|
|
19
|
+
}
|
|
20
|
+
return { code: "PAGE_ERROR", message: String(value) };
|
|
21
|
+
}
|