@pmate/cli 0.13.3 → 0.15.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/README.md +9 -3
- package/dist/index.d.ts +52 -1
- package/dist/index.js +1009 -294
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -34,6 +34,149 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
34
34
|
));
|
|
35
35
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
36
36
|
|
|
37
|
+
// src/sessionStore.ts
|
|
38
|
+
function buildSessionStorePath() {
|
|
39
|
+
return import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate", "session.json");
|
|
40
|
+
}
|
|
41
|
+
function saveLoginSession(session, requestedApp = DEFAULT_APP_ID) {
|
|
42
|
+
const store = loadExistingSessionStoreOrEmpty();
|
|
43
|
+
const app = resolveStoredAppId(session, requestedApp);
|
|
44
|
+
const nextSession = {
|
|
45
|
+
...session,
|
|
46
|
+
app,
|
|
47
|
+
session: {
|
|
48
|
+
...session.session,
|
|
49
|
+
...session.session.app ? {} : { app }
|
|
50
|
+
},
|
|
51
|
+
updatedAt: (/* @__PURE__ */ new Date()).toISOString()
|
|
52
|
+
};
|
|
53
|
+
store.sessions[app] = nextSession;
|
|
54
|
+
store.activeApp = app;
|
|
55
|
+
writeSessionStore(store);
|
|
56
|
+
return {
|
|
57
|
+
app,
|
|
58
|
+
sessionPath: buildSessionStorePath()
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
function readRequiredSession(options) {
|
|
62
|
+
const { sessionPath, store } = loadSessionStoreWithPath();
|
|
63
|
+
const resolvedApp = resolveReadApp(store, options);
|
|
64
|
+
const session = store.sessions[resolvedApp];
|
|
65
|
+
if (!session) {
|
|
66
|
+
throw new Error(buildMissingSessionMessage(sessionPath, resolvedApp));
|
|
67
|
+
}
|
|
68
|
+
const token = session.token?.trim();
|
|
69
|
+
if (!token) {
|
|
70
|
+
throw new Error(`Missing token in ${sessionPath}. Run "pmate login --app ${resolvedApp}" again.`);
|
|
71
|
+
}
|
|
72
|
+
return {
|
|
73
|
+
...session,
|
|
74
|
+
token
|
|
75
|
+
};
|
|
76
|
+
}
|
|
77
|
+
function loadSessionStore() {
|
|
78
|
+
return loadSessionStoreWithPath().store;
|
|
79
|
+
}
|
|
80
|
+
function loadExistingSessionStoreOrEmpty() {
|
|
81
|
+
const sessionPath = buildSessionStorePath();
|
|
82
|
+
if (!(0, import_node_fs2.existsSync)(sessionPath)) {
|
|
83
|
+
return {
|
|
84
|
+
version: SESSION_STORE_VERSION,
|
|
85
|
+
activeApp: DEFAULT_APP_ID,
|
|
86
|
+
sessions: {}
|
|
87
|
+
};
|
|
88
|
+
}
|
|
89
|
+
return loadSessionStore();
|
|
90
|
+
}
|
|
91
|
+
function loadSessionStoreWithPath() {
|
|
92
|
+
const sessionPath = buildSessionStorePath();
|
|
93
|
+
if (!(0, import_node_fs2.existsSync)(sessionPath)) {
|
|
94
|
+
throw new Error(`Missing session file at ${sessionPath}. Run "pmate login" first.`);
|
|
95
|
+
}
|
|
96
|
+
const raw = (0, import_node_fs2.readFileSync)(sessionPath, "utf8");
|
|
97
|
+
const parsed = JSON.parse(raw);
|
|
98
|
+
const store = normalizeStore(parsed);
|
|
99
|
+
const nextRaw = JSON.stringify(store, null, 2);
|
|
100
|
+
if (nextRaw !== raw.trim()) {
|
|
101
|
+
writeSessionStore(store);
|
|
102
|
+
}
|
|
103
|
+
return { sessionPath, store };
|
|
104
|
+
}
|
|
105
|
+
function normalizeStore(value) {
|
|
106
|
+
if (isSessionStore(value)) {
|
|
107
|
+
return {
|
|
108
|
+
version: SESSION_STORE_VERSION,
|
|
109
|
+
activeApp: value.activeApp || DEFAULT_APP_ID,
|
|
110
|
+
sessions: value.sessions || {}
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
const legacy = value;
|
|
114
|
+
const app = resolveStoredAppId(legacy, legacy.session?.app || legacy.app || DEFAULT_APP_ID);
|
|
115
|
+
return {
|
|
116
|
+
version: SESSION_STORE_VERSION,
|
|
117
|
+
activeApp: app,
|
|
118
|
+
sessions: {
|
|
119
|
+
[app]: {
|
|
120
|
+
...legacy,
|
|
121
|
+
app,
|
|
122
|
+
session: {
|
|
123
|
+
...legacy.session,
|
|
124
|
+
...legacy.session?.app ? {} : { app }
|
|
125
|
+
},
|
|
126
|
+
updatedAt: (/* @__PURE__ */ new Date()).toISOString()
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
};
|
|
130
|
+
}
|
|
131
|
+
function isSessionStore(value) {
|
|
132
|
+
return !!value && typeof value === "object" && "version" in value && "sessions" in value && typeof value.sessions === "object";
|
|
133
|
+
}
|
|
134
|
+
function resolveStoredAppId(session, fallbackApp) {
|
|
135
|
+
return session.session?.app?.trim() || session.app?.trim() || fallbackApp.trim() || DEFAULT_APP_ID;
|
|
136
|
+
}
|
|
137
|
+
function resolveReadApp(store, options) {
|
|
138
|
+
const requestedApp = options?.app?.trim();
|
|
139
|
+
if (requestedApp) {
|
|
140
|
+
return requestedApp;
|
|
141
|
+
}
|
|
142
|
+
const preferredApp = options?.preferredApp?.trim();
|
|
143
|
+
if (preferredApp && store.sessions[preferredApp]) {
|
|
144
|
+
return preferredApp;
|
|
145
|
+
}
|
|
146
|
+
if (options?.fallbackToActiveApp && store.activeApp && store.sessions[store.activeApp]) {
|
|
147
|
+
return store.activeApp;
|
|
148
|
+
}
|
|
149
|
+
return preferredApp || store.activeApp || DEFAULT_APP_ID;
|
|
150
|
+
}
|
|
151
|
+
function writeSessionStore(store) {
|
|
152
|
+
const sessionPath = buildSessionStorePath();
|
|
153
|
+
(0, import_node_fs2.mkdirSync)(import_node_path3.default.dirname(sessionPath), { recursive: true });
|
|
154
|
+
(0, import_node_fs2.writeFileSync)(sessionPath, JSON.stringify(store, null, 2), {
|
|
155
|
+
mode: 384
|
|
156
|
+
});
|
|
157
|
+
try {
|
|
158
|
+
(0, import_node_fs2.chmodSync)(sessionPath, 384);
|
|
159
|
+
} catch {
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
function buildMissingSessionMessage(sessionPath, app) {
|
|
163
|
+
if (app === DEFAULT_APP_ID) {
|
|
164
|
+
return `Missing ${DEFAULT_APP_ID} session in ${sessionPath}. Run "pmate login" first.`;
|
|
165
|
+
}
|
|
166
|
+
return `Missing session for app ${app} in ${sessionPath}. Run "pmate login --app ${app}" first.`;
|
|
167
|
+
}
|
|
168
|
+
var import_node_fs2, import_node_os2, import_node_path3, DEFAULT_APP_ID, SESSION_STORE_VERSION;
|
|
169
|
+
var init_sessionStore = __esm({
|
|
170
|
+
"src/sessionStore.ts"() {
|
|
171
|
+
"use strict";
|
|
172
|
+
import_node_fs2 = require("fs");
|
|
173
|
+
import_node_os2 = __toESM(require("os"));
|
|
174
|
+
import_node_path3 = __toESM(require("path"));
|
|
175
|
+
DEFAULT_APP_ID = "@pmate/cli";
|
|
176
|
+
SESSION_STORE_VERSION = 2;
|
|
177
|
+
}
|
|
178
|
+
});
|
|
179
|
+
|
|
37
180
|
// node_modules/.pnpm/@pmate+meta@1.1.2/node_modules/@pmate/meta/dist/types/account.types.js
|
|
38
181
|
var require_account_types = __commonJS({
|
|
39
182
|
"node_modules/.pnpm/@pmate+meta@1.1.2/node_modules/@pmate/meta/dist/types/account.types.js"(exports2) {
|
|
@@ -12406,17 +12549,9 @@ function resolveHubBaseUrl(value) {
|
|
|
12406
12549
|
return (value || process.env.PMATE_AGENT_HUB_BASE_URL || DEFAULT_AGENT_HUB_BASE_URL).replace(/\/+$/, "");
|
|
12407
12550
|
}
|
|
12408
12551
|
function readSessionToken() {
|
|
12409
|
-
|
|
12410
|
-
|
|
12411
|
-
|
|
12412
|
-
}
|
|
12413
|
-
const raw = (0, import_node_fs9.readFileSync)(sessionPath, "utf8");
|
|
12414
|
-
const parsed = JSON.parse(raw);
|
|
12415
|
-
const token = parsed.token?.trim();
|
|
12416
|
-
if (!token) {
|
|
12417
|
-
throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
|
|
12418
|
-
}
|
|
12419
|
-
return token;
|
|
12552
|
+
return readRequiredSession({
|
|
12553
|
+
preferredApp: DEFAULT_APP_ID
|
|
12554
|
+
}).token;
|
|
12420
12555
|
}
|
|
12421
12556
|
function unwrapAgentResult(value) {
|
|
12422
12557
|
if (!value || typeof value !== "object") {
|
|
@@ -12427,14 +12562,12 @@ function unwrapAgentResult(value) {
|
|
|
12427
12562
|
}
|
|
12428
12563
|
return value;
|
|
12429
12564
|
}
|
|
12430
|
-
var
|
|
12565
|
+
var import_agent_sdk, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_FROM, AgentLlmClient;
|
|
12431
12566
|
var init_AgentLlmClient = __esm({
|
|
12432
12567
|
"src/llm/AgentLlmClient.ts"() {
|
|
12433
12568
|
"use strict";
|
|
12434
|
-
import_node_fs9 = require("fs");
|
|
12435
|
-
import_node_os4 = __toESM(require("os"));
|
|
12436
|
-
import_node_path13 = __toESM(require("path"));
|
|
12437
12569
|
import_agent_sdk = __toESM(require_dist4());
|
|
12570
|
+
init_sessionStore();
|
|
12438
12571
|
DEFAULT_AGENT_API_BASE_URL = "https://agent-api.pmate.chat";
|
|
12439
12572
|
DEFAULT_AGENT_HUB_BASE_URL = "https://hub.pmate.chat";
|
|
12440
12573
|
DEFAULT_NAMESPACE = "pmate-cli";
|
|
@@ -12479,8 +12612,8 @@ __export(index_exports, {
|
|
|
12479
12612
|
parseCommandArgs: () => parseCommandArgs
|
|
12480
12613
|
});
|
|
12481
12614
|
module.exports = __toCommonJS(index_exports);
|
|
12482
|
-
var
|
|
12483
|
-
var
|
|
12615
|
+
var import_node_fs15 = require("fs");
|
|
12616
|
+
var import_node_path20 = __toESM(require("path"));
|
|
12484
12617
|
var import_chalk3 = __toESM(require("chalk"));
|
|
12485
12618
|
|
|
12486
12619
|
// src/cli.ts
|
|
@@ -12910,15 +13043,12 @@ var ListCommandHandler = class {
|
|
|
12910
13043
|
};
|
|
12911
13044
|
|
|
12912
13045
|
// src/commands/LoginCommandHandler.ts
|
|
12913
|
-
var import_node_fs2 = require("fs");
|
|
12914
13046
|
var import_node_http = require("http");
|
|
12915
|
-
var import_node_os2 = __toESM(require("os"));
|
|
12916
|
-
var import_node_path3 = __toESM(require("path"));
|
|
12917
13047
|
var import_node_child_process = require("child_process");
|
|
13048
|
+
init_sessionStore();
|
|
12918
13049
|
var AUTH_UI_BASE_URL = "https://auth.pmate.chat";
|
|
12919
13050
|
var AUTH_API_BASE_URL = "https://auth-api-v2.pmate.chat";
|
|
12920
13051
|
var CALLBACK_PATH = "/pmate-login-callback";
|
|
12921
|
-
var DEFAULT_APP_ID = "@pmate/cli";
|
|
12922
13052
|
var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
|
|
12923
13053
|
function buildHostedLoginUrl(redirectUrl, appId = DEFAULT_APP_ID) {
|
|
12924
13054
|
const url = new URL(AUTH_UI_BASE_URL);
|
|
@@ -12945,15 +13075,17 @@ var LoginCommandHandler = class {
|
|
|
12945
13075
|
});
|
|
12946
13076
|
try {
|
|
12947
13077
|
const token = await callback.waitForToken;
|
|
12948
|
-
const loginResponse = await this.fetchSession(token);
|
|
12949
|
-
const
|
|
12950
|
-
ui.success(`Logged in. Session saved to ${sessionPath}`);
|
|
13078
|
+
const loginResponse = await this.fetchSession(token, appId);
|
|
13079
|
+
const saved = saveLoginSession(loginResponse, appId);
|
|
13080
|
+
ui.success(`Logged in to ${saved.app}. Session saved to ${saved.sessionPath}`);
|
|
12951
13081
|
} finally {
|
|
12952
13082
|
await callback.close();
|
|
12953
13083
|
}
|
|
12954
13084
|
}
|
|
12955
|
-
async fetchSession(token) {
|
|
12956
|
-
const
|
|
13085
|
+
async fetchSession(token, appId) {
|
|
13086
|
+
const url = new URL(`${AUTH_API_BASE_URL}/session`);
|
|
13087
|
+
url.searchParams.set("app", appId);
|
|
13088
|
+
const response = await fetch(url.toString(), {
|
|
12957
13089
|
method: "GET",
|
|
12958
13090
|
headers: {
|
|
12959
13091
|
Authorization: `Bearer ${token}`
|
|
@@ -13071,19 +13203,6 @@ var LoginCommandHandler = class {
|
|
|
13071
13203
|
return false;
|
|
13072
13204
|
}
|
|
13073
13205
|
}
|
|
13074
|
-
writeSession(session) {
|
|
13075
|
-
const sessionDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".pmate");
|
|
13076
|
-
const sessionPath = import_node_path3.default.join(sessionDir, "session.json");
|
|
13077
|
-
(0, import_node_fs2.mkdirSync)(sessionDir, { recursive: true });
|
|
13078
|
-
(0, import_node_fs2.writeFileSync)(sessionPath, JSON.stringify(session, null, 2), {
|
|
13079
|
-
mode: 384
|
|
13080
|
-
});
|
|
13081
|
-
try {
|
|
13082
|
-
(0, import_node_fs2.chmodSync)(sessionPath, 384);
|
|
13083
|
-
} catch {
|
|
13084
|
-
}
|
|
13085
|
-
return sessionPath;
|
|
13086
|
-
}
|
|
13087
13206
|
};
|
|
13088
13207
|
|
|
13089
13208
|
// src/services/AliyunService.ts
|
|
@@ -13673,10 +13792,8 @@ var AddDnsCommandHandler = class {
|
|
|
13673
13792
|
};
|
|
13674
13793
|
|
|
13675
13794
|
// src/commands/StsCommandHandler.ts
|
|
13676
|
-
var import_node_fs4 = require("fs");
|
|
13677
|
-
var import_node_os3 = __toESM(require("os"));
|
|
13678
|
-
var import_node_path5 = __toESM(require("path"));
|
|
13679
13795
|
var import_chalk2 = __toESM(require("chalk"));
|
|
13796
|
+
init_sessionStore();
|
|
13680
13797
|
var StsCommandHandler = class {
|
|
13681
13798
|
async handle(_args) {
|
|
13682
13799
|
const session = this.readSession();
|
|
@@ -13704,12 +13821,9 @@ var StsCommandHandler = class {
|
|
|
13704
13821
|
ui.plain(import_chalk2.default.cyan(JSON.stringify(payload, null, 2)));
|
|
13705
13822
|
}
|
|
13706
13823
|
readSession() {
|
|
13707
|
-
|
|
13708
|
-
|
|
13709
|
-
|
|
13710
|
-
}
|
|
13711
|
-
const raw = (0, import_node_fs4.readFileSync)(sessionPath, "utf8");
|
|
13712
|
-
return JSON.parse(raw);
|
|
13824
|
+
return readRequiredSession({
|
|
13825
|
+
preferredApp: DEFAULT_APP_ID
|
|
13826
|
+
});
|
|
13713
13827
|
}
|
|
13714
13828
|
};
|
|
13715
13829
|
|
|
@@ -13723,12 +13837,12 @@ var BucketCommandHandler = class {
|
|
|
13723
13837
|
};
|
|
13724
13838
|
|
|
13725
13839
|
// src/commands/DeployCommandHandler.ts
|
|
13726
|
-
var
|
|
13727
|
-
var
|
|
13840
|
+
var import_node_fs4 = require("fs");
|
|
13841
|
+
var import_node_path6 = __toESM(require("path"));
|
|
13728
13842
|
var import_node_child_process2 = require("child_process");
|
|
13729
13843
|
|
|
13730
13844
|
// src/appDir.ts
|
|
13731
|
-
var
|
|
13845
|
+
var import_node_path5 = __toESM(require("path"));
|
|
13732
13846
|
function normalizeRelativeDir(input, appName) {
|
|
13733
13847
|
if (typeof input !== "string") {
|
|
13734
13848
|
throw new Error(`Missing dir for ${appName} in .pmate.yaml`);
|
|
@@ -13741,7 +13855,7 @@ function normalizeRelativeDir(input, appName) {
|
|
|
13741
13855
|
if (unixLike.startsWith("/")) {
|
|
13742
13856
|
throw new Error(`Invalid dir for ${appName} in .pmate.yaml: must be relative`);
|
|
13743
13857
|
}
|
|
13744
|
-
const normalized =
|
|
13858
|
+
const normalized = import_node_path5.default.posix.normalize(unixLike);
|
|
13745
13859
|
if (normalized.startsWith("../") || normalized === "..") {
|
|
13746
13860
|
throw new Error(
|
|
13747
13861
|
`Invalid dir for ${appName} in .pmate.yaml: must stay within repo`
|
|
@@ -13751,7 +13865,7 @@ function normalizeRelativeDir(input, appName) {
|
|
|
13751
13865
|
}
|
|
13752
13866
|
function resolveLocalAppDir(repoRoot, appName, dir) {
|
|
13753
13867
|
const relative = normalizeRelativeDir(dir, appName);
|
|
13754
|
-
return
|
|
13868
|
+
return import_node_path5.default.resolve(repoRoot, relative);
|
|
13755
13869
|
}
|
|
13756
13870
|
function resolveRemoteAppDir(appName, dir) {
|
|
13757
13871
|
return normalizeRelativeDir(dir, appName);
|
|
@@ -13823,8 +13937,8 @@ var DeployCommandHandler = class {
|
|
|
13823
13937
|
}
|
|
13824
13938
|
async deployVite(appName, cwd, appConfig) {
|
|
13825
13939
|
const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
|
|
13826
|
-
const packageJsonPath =
|
|
13827
|
-
if (!(0,
|
|
13940
|
+
const packageJsonPath = import_node_path6.default.join(appDir, "package.json");
|
|
13941
|
+
if (!(0, import_node_fs4.existsSync)(packageJsonPath)) {
|
|
13828
13942
|
throw new Error(`No package.json found at ${packageJsonPath}`);
|
|
13829
13943
|
}
|
|
13830
13944
|
const pkg2 = this.loadPackageJson(packageJsonPath);
|
|
@@ -13833,28 +13947,28 @@ var DeployCommandHandler = class {
|
|
|
13833
13947
|
throw new Error(`Missing package name in ${packageJsonPath}`);
|
|
13834
13948
|
}
|
|
13835
13949
|
await this.runCommand("pnpm", ["--filter", pkgName, "build"], cwd);
|
|
13836
|
-
const distDir =
|
|
13837
|
-
if (!(0,
|
|
13950
|
+
const distDir = import_node_path6.default.join(appDir, "dist");
|
|
13951
|
+
if (!(0, import_node_fs4.existsSync)(distDir)) {
|
|
13838
13952
|
throw new Error(`No dist directory found at ${distDir}`);
|
|
13839
13953
|
}
|
|
13840
13954
|
const bucketName = appConfig.bucket?.trim();
|
|
13841
13955
|
if (!bucketName) {
|
|
13842
13956
|
throw new Error(
|
|
13843
|
-
`Missing bucket for ${appName} in ${
|
|
13957
|
+
`Missing bucket for ${appName} in ${import_node_path6.default.join(cwd, ".pmate.yaml")}`
|
|
13844
13958
|
);
|
|
13845
13959
|
}
|
|
13846
13960
|
await AliyunService.uploadDirectory(distDir, bucketName);
|
|
13847
13961
|
}
|
|
13848
13962
|
async deployStatic(appName, cwd, appConfig) {
|
|
13849
13963
|
const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
|
|
13850
|
-
const srcDir =
|
|
13851
|
-
if (!(0,
|
|
13964
|
+
const srcDir = import_node_path6.default.join(appDir, "src");
|
|
13965
|
+
if (!(0, import_node_fs4.existsSync)(srcDir)) {
|
|
13852
13966
|
throw new Error(`No src directory found at ${srcDir}`);
|
|
13853
13967
|
}
|
|
13854
13968
|
const bucketName = appConfig.bucket?.trim();
|
|
13855
13969
|
if (!bucketName) {
|
|
13856
13970
|
throw new Error(
|
|
13857
|
-
`Missing bucket for ${appName} in ${
|
|
13971
|
+
`Missing bucket for ${appName} in ${import_node_path6.default.join(cwd, ".pmate.yaml")}`
|
|
13858
13972
|
);
|
|
13859
13973
|
}
|
|
13860
13974
|
await AliyunService.uploadDirectory(srcDir, bucketName);
|
|
@@ -13960,10 +14074,10 @@ var DeployCommandHandler = class {
|
|
|
13960
14074
|
await this.runRemoteCommand(server, command);
|
|
13961
14075
|
}
|
|
13962
14076
|
resolveCwd(target) {
|
|
13963
|
-
return target ?
|
|
14077
|
+
return target ? import_node_path6.default.resolve(process.cwd(), target) : process.cwd();
|
|
13964
14078
|
}
|
|
13965
14079
|
loadPackageJson(packageJsonPath) {
|
|
13966
|
-
const raw = (0,
|
|
14080
|
+
const raw = (0, import_node_fs4.readFileSync)(packageJsonPath, "utf8");
|
|
13967
14081
|
const parsed = JSON.parse(raw);
|
|
13968
14082
|
if (!parsed || typeof parsed !== "object") {
|
|
13969
14083
|
throw new Error(`Invalid package.json at ${packageJsonPath}`);
|
|
@@ -14041,7 +14155,7 @@ var DeployCommandHandler = class {
|
|
|
14041
14155
|
};
|
|
14042
14156
|
|
|
14043
14157
|
// src/commands/LogCommandHandler.ts
|
|
14044
|
-
var
|
|
14158
|
+
var import_node_path7 = __toESM(require("path"));
|
|
14045
14159
|
var LogCommandHandler = class {
|
|
14046
14160
|
async handle(args) {
|
|
14047
14161
|
const appName = args.logApp.trim();
|
|
@@ -14065,7 +14179,7 @@ var LogCommandHandler = class {
|
|
|
14065
14179
|
this.renderPage(page);
|
|
14066
14180
|
}
|
|
14067
14181
|
resolveCwd(target) {
|
|
14068
|
-
return target ?
|
|
14182
|
+
return target ? import_node_path7.default.resolve(process.cwd(), target) : process.cwd();
|
|
14069
14183
|
}
|
|
14070
14184
|
loadClosestConfig(cwd) {
|
|
14071
14185
|
const loaded = loadAppConfig(cwd, { searchParents: true });
|
|
@@ -14112,8 +14226,8 @@ var LogCommandHandler = class {
|
|
|
14112
14226
|
};
|
|
14113
14227
|
|
|
14114
14228
|
// src/commands/InitCommandHandler.ts
|
|
14115
|
-
var
|
|
14116
|
-
var
|
|
14229
|
+
var import_node_fs5 = require("fs");
|
|
14230
|
+
var import_node_path8 = __toESM(require("path"));
|
|
14117
14231
|
var import_node_child_process3 = require("child_process");
|
|
14118
14232
|
var import_promises2 = require("readline/promises");
|
|
14119
14233
|
var import_yaml2 = __toESM(require("yaml"));
|
|
@@ -14151,7 +14265,7 @@ var InitCommandHandler = class {
|
|
|
14151
14265
|
}
|
|
14152
14266
|
if (appConfig.type !== "rust") {
|
|
14153
14267
|
const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
|
|
14154
|
-
if (!(0,
|
|
14268
|
+
if (!(0, import_node_fs5.existsSync)(appDir)) {
|
|
14155
14269
|
throw new Error(`No app folder found at ${appDir}`);
|
|
14156
14270
|
}
|
|
14157
14271
|
}
|
|
@@ -14180,12 +14294,12 @@ var InitCommandHandler = class {
|
|
|
14180
14294
|
const bucketName = appConfig.bucket?.trim();
|
|
14181
14295
|
if (!bucketName) {
|
|
14182
14296
|
throw new Error(
|
|
14183
|
-
`Missing bucket for ${appName} in ${
|
|
14297
|
+
`Missing bucket for ${appName} in ${import_node_path8.default.join(cwd, ".pmate.yaml")}`
|
|
14184
14298
|
);
|
|
14185
14299
|
}
|
|
14186
14300
|
const baseDomain = config.domain?.trim();
|
|
14187
14301
|
if (!baseDomain) {
|
|
14188
|
-
throw new Error(`Missing domain in ${
|
|
14302
|
+
throw new Error(`Missing domain in ${import_node_path8.default.join(cwd, ".pmate.yaml")}`);
|
|
14189
14303
|
}
|
|
14190
14304
|
const subdomain = appConfig.subdomain?.trim();
|
|
14191
14305
|
const dnsRr = subdomain || "@";
|
|
@@ -14319,7 +14433,7 @@ var InitCommandHandler = class {
|
|
|
14319
14433
|
const serverAddress = await resolveServerAddress(server);
|
|
14320
14434
|
const templateName = serviceType === "ws" ? "nginx.ws.template" : "nginx.rest.template";
|
|
14321
14435
|
const templatePath = this.resolveTemplatePath(templateName);
|
|
14322
|
-
const template = (0,
|
|
14436
|
+
const template = (0, import_node_fs5.readFileSync)(templatePath, "utf8");
|
|
14323
14437
|
const host = `${subdomain}.pmate.chat`;
|
|
14324
14438
|
const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
|
|
14325
14439
|
const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
|
|
@@ -14352,15 +14466,15 @@ var InitCommandHandler = class {
|
|
|
14352
14466
|
if (options.ensurePackageJson) {
|
|
14353
14467
|
const appDir = resolveLocalAppDir(cwd, appConfig.app, appConfig.dir);
|
|
14354
14468
|
ui.info(`Resolved appDir: ${appDir}`);
|
|
14355
|
-
if (!(0,
|
|
14469
|
+
if (!(0, import_node_fs5.existsSync)(appDir)) {
|
|
14356
14470
|
throw new Error(`Missing app folder at ${appDir}`);
|
|
14357
14471
|
}
|
|
14358
|
-
const packageJsonPath =
|
|
14472
|
+
const packageJsonPath = import_node_path8.default.join(appDir, "package.json");
|
|
14359
14473
|
ui.info(`Resolved package.json: ${packageJsonPath}`);
|
|
14360
|
-
if (!(0,
|
|
14474
|
+
if (!(0, import_node_fs5.existsSync)(packageJsonPath)) {
|
|
14361
14475
|
throw new Error(`Missing package.json at ${packageJsonPath}`);
|
|
14362
14476
|
}
|
|
14363
|
-
const pkgStat = (0,
|
|
14477
|
+
const pkgStat = (0, import_node_fs5.statSync)(packageJsonPath);
|
|
14364
14478
|
ui.info(
|
|
14365
14479
|
`package.json stat: isFile=${pkgStat.isFile()} isDirectory=${pkgStat.isDirectory()}`
|
|
14366
14480
|
);
|
|
@@ -14380,12 +14494,12 @@ var InitCommandHandler = class {
|
|
|
14380
14494
|
}
|
|
14381
14495
|
resolveTemplatePath(templateName) {
|
|
14382
14496
|
const candidates = [
|
|
14383
|
-
|
|
14384
|
-
|
|
14385
|
-
|
|
14497
|
+
import_node_path8.default.join(__dirname, "templates", templateName),
|
|
14498
|
+
import_node_path8.default.join(__dirname, "..", "templates", templateName),
|
|
14499
|
+
import_node_path8.default.join(__dirname, "..", "src", "templates", templateName)
|
|
14386
14500
|
];
|
|
14387
14501
|
for (const candidate of candidates) {
|
|
14388
|
-
if ((0,
|
|
14502
|
+
if ((0, import_node_fs5.existsSync)(candidate)) {
|
|
14389
14503
|
return candidate;
|
|
14390
14504
|
}
|
|
14391
14505
|
}
|
|
@@ -14433,7 +14547,7 @@ var InitCommandHandler = class {
|
|
|
14433
14547
|
});
|
|
14434
14548
|
}
|
|
14435
14549
|
resolveCwd(target) {
|
|
14436
|
-
return target ?
|
|
14550
|
+
return target ? import_node_path8.default.resolve(process.cwd(), target) : process.cwd();
|
|
14437
14551
|
}
|
|
14438
14552
|
sleep(ms) {
|
|
14439
14553
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
@@ -14557,7 +14671,7 @@ var InitCommandHandler = class {
|
|
|
14557
14671
|
}
|
|
14558
14672
|
}
|
|
14559
14673
|
loadPackageJson(packageJsonPath) {
|
|
14560
|
-
const raw = (0,
|
|
14674
|
+
const raw = (0, import_node_fs5.readFileSync)(packageJsonPath, "utf8");
|
|
14561
14675
|
const parsed = JSON.parse(raw);
|
|
14562
14676
|
if (!parsed || typeof parsed !== "object") {
|
|
14563
14677
|
throw new Error(`Invalid package.json at ${packageJsonPath}`);
|
|
@@ -14566,13 +14680,13 @@ var InitCommandHandler = class {
|
|
|
14566
14680
|
}
|
|
14567
14681
|
writePackageJson(packageJsonPath, data) {
|
|
14568
14682
|
const serialized = JSON.stringify(data, null, 2);
|
|
14569
|
-
(0,
|
|
14683
|
+
(0, import_node_fs5.writeFileSync)(packageJsonPath, `${serialized}
|
|
14570
14684
|
`, "utf8");
|
|
14571
14685
|
}
|
|
14572
14686
|
writeConfig(cwd, config) {
|
|
14573
|
-
const configPath =
|
|
14687
|
+
const configPath = import_node_path8.default.join(cwd, ".pmate.yaml");
|
|
14574
14688
|
const serialized = import_yaml2.default.stringify(config).trimEnd();
|
|
14575
|
-
(0,
|
|
14689
|
+
(0, import_node_fs5.writeFileSync)(configPath, `${serialized}
|
|
14576
14690
|
`, "utf8");
|
|
14577
14691
|
}
|
|
14578
14692
|
async promptRequired(rl, question) {
|
|
@@ -14608,8 +14722,8 @@ var InitCommandHandler = class {
|
|
|
14608
14722
|
};
|
|
14609
14723
|
|
|
14610
14724
|
// src/commands/DevCommandHandler.ts
|
|
14611
|
-
var
|
|
14612
|
-
var
|
|
14725
|
+
var import_node_fs6 = require("fs");
|
|
14726
|
+
var import_node_path9 = __toESM(require("path"));
|
|
14613
14727
|
var import_node_child_process4 = require("child_process");
|
|
14614
14728
|
var DevCommandHandler = class {
|
|
14615
14729
|
async handle(args) {
|
|
@@ -14627,8 +14741,8 @@ var DevCommandHandler = class {
|
|
|
14627
14741
|
);
|
|
14628
14742
|
}
|
|
14629
14743
|
const appDir = resolveLocalAppDir(cwd, appName, appConfig.dir);
|
|
14630
|
-
const packageJsonPath =
|
|
14631
|
-
if (!(0,
|
|
14744
|
+
const packageJsonPath = import_node_path9.default.join(appDir, "package.json");
|
|
14745
|
+
if (!(0, import_node_fs6.existsSync)(packageJsonPath)) {
|
|
14632
14746
|
throw new Error(`No package.json found at ${packageJsonPath}`);
|
|
14633
14747
|
}
|
|
14634
14748
|
const pkg2 = this.loadPackageJson(packageJsonPath);
|
|
@@ -14642,13 +14756,13 @@ var DevCommandHandler = class {
|
|
|
14642
14756
|
await this.runCommand("pnpm", ["--filter", pkgName, "run", "dev"], cwd);
|
|
14643
14757
|
}
|
|
14644
14758
|
resolveCwd(target) {
|
|
14645
|
-
return target ?
|
|
14759
|
+
return target ? import_node_path9.default.resolve(process.cwd(), target) : process.cwd();
|
|
14646
14760
|
}
|
|
14647
14761
|
loadConfig(cwd) {
|
|
14648
14762
|
return loadAppConfig(cwd);
|
|
14649
14763
|
}
|
|
14650
14764
|
loadPackageJson(packageJsonPath) {
|
|
14651
|
-
const raw = (0,
|
|
14765
|
+
const raw = (0, import_node_fs6.readFileSync)(packageJsonPath, "utf8");
|
|
14652
14766
|
const parsed = JSON.parse(raw);
|
|
14653
14767
|
if (!parsed || typeof parsed !== "object") {
|
|
14654
14768
|
throw new Error(`Invalid package.json at ${packageJsonPath}`);
|
|
@@ -14676,8 +14790,8 @@ var DevCommandHandler = class {
|
|
|
14676
14790
|
};
|
|
14677
14791
|
|
|
14678
14792
|
// src/commands/OssCommandHandler.ts
|
|
14679
|
-
var
|
|
14680
|
-
var
|
|
14793
|
+
var import_node_fs7 = require("fs");
|
|
14794
|
+
var import_node_path10 = __toESM(require("path"));
|
|
14681
14795
|
var OssCommandHandler = class _OssCommandHandler {
|
|
14682
14796
|
static {
|
|
14683
14797
|
this.DEFAULT_BUCKET = "parrot-static";
|
|
@@ -14694,17 +14808,17 @@ var OssCommandHandler = class _OssCommandHandler {
|
|
|
14694
14808
|
}
|
|
14695
14809
|
return;
|
|
14696
14810
|
}
|
|
14697
|
-
const resolvedFile =
|
|
14811
|
+
const resolvedFile = import_node_path10.default.resolve(process.cwd(), args.filePath);
|
|
14698
14812
|
this.assertFile(resolvedFile);
|
|
14699
14813
|
const objectKey = this.normalizeObjectKey(args.objectKey);
|
|
14700
14814
|
const bucket = this.resolveBucket(args.bucket);
|
|
14701
14815
|
await AliyunService.uploadFile(resolvedFile, bucket, objectKey);
|
|
14702
14816
|
}
|
|
14703
14817
|
assertFile(filePath) {
|
|
14704
|
-
if (!(0,
|
|
14818
|
+
if (!(0, import_node_fs7.existsSync)(filePath)) {
|
|
14705
14819
|
throw new Error(`File not found: ${filePath}`);
|
|
14706
14820
|
}
|
|
14707
|
-
const stat = (0,
|
|
14821
|
+
const stat = (0, import_node_fs7.statSync)(filePath);
|
|
14708
14822
|
if (!stat.isFile()) {
|
|
14709
14823
|
throw new Error(`Not a file: ${filePath}`);
|
|
14710
14824
|
}
|
|
@@ -14726,7 +14840,7 @@ var OssCommandHandler = class _OssCommandHandler {
|
|
|
14726
14840
|
};
|
|
14727
14841
|
|
|
14728
14842
|
// src/commands/EnvCommandHandler.ts
|
|
14729
|
-
var
|
|
14843
|
+
var import_node_path11 = __toESM(require("path"));
|
|
14730
14844
|
var import_node_child_process5 = require("child_process");
|
|
14731
14845
|
var EnvCommandHandler = class {
|
|
14732
14846
|
async handle(args) {
|
|
@@ -14800,8 +14914,8 @@ var EnvCommandHandler = class {
|
|
|
14800
14914
|
ui.success(`Set ${envKey} in .env.local`, appName);
|
|
14801
14915
|
}
|
|
14802
14916
|
async listEnvKeys(server, repoDir, appDir, verbose) {
|
|
14803
|
-
const envLocalPath =
|
|
14804
|
-
const envPath =
|
|
14917
|
+
const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
|
|
14918
|
+
const envPath = import_node_path11.default.posix.join(appDir, ".env");
|
|
14805
14919
|
if (verbose) {
|
|
14806
14920
|
const repoPath = `$HOME/${repoDir}`;
|
|
14807
14921
|
ui.info("Env list target", {
|
|
@@ -14894,8 +15008,8 @@ var EnvCommandHandler = class {
|
|
|
14894
15008
|
}
|
|
14895
15009
|
}
|
|
14896
15010
|
async appendEnvLine(server, repoDir, appDir, envKey, envLine, verbose) {
|
|
14897
|
-
const envLocalPath =
|
|
14898
|
-
const envPath =
|
|
15011
|
+
const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
|
|
15012
|
+
const envPath = import_node_path11.default.posix.join(appDir, ".env");
|
|
14899
15013
|
if (verbose) {
|
|
14900
15014
|
const repoPath = `$HOME/${repoDir}`;
|
|
14901
15015
|
ui.info("Env add target", {
|
|
@@ -14943,8 +15057,8 @@ var EnvCommandHandler = class {
|
|
|
14943
15057
|
await this.runRemoteCommand(server, command);
|
|
14944
15058
|
}
|
|
14945
15059
|
async deleteEnvKey(server, repoDir, appDir, envKey, verbose) {
|
|
14946
|
-
const envLocalPath =
|
|
14947
|
-
const envPath =
|
|
15060
|
+
const envLocalPath = import_node_path11.default.posix.join(appDir, ".env.local");
|
|
15061
|
+
const envPath = import_node_path11.default.posix.join(appDir, ".env");
|
|
14948
15062
|
if (verbose) {
|
|
14949
15063
|
const repoPath = `$HOME/${repoDir}`;
|
|
14950
15064
|
ui.info("Env delete target", {
|
|
@@ -15714,7 +15828,7 @@ var CommitCommandHandler = class {
|
|
|
15714
15828
|
|
|
15715
15829
|
// src/commands/SummaryCommandHandler.ts
|
|
15716
15830
|
var import_node_child_process7 = require("child_process");
|
|
15717
|
-
var
|
|
15831
|
+
var import_node_path12 = __toESM(require("path"));
|
|
15718
15832
|
var SummaryCommandHandler = class {
|
|
15719
15833
|
async handle(args) {
|
|
15720
15834
|
const cwd = this.resolveCwd(args.cwd);
|
|
@@ -15899,7 +16013,7 @@ var SummaryCommandHandler = class {
|
|
|
15899
16013
|
return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
|
|
15900
16014
|
}
|
|
15901
16015
|
resolveCwd(value) {
|
|
15902
|
-
return value ?
|
|
16016
|
+
return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
|
|
15903
16017
|
}
|
|
15904
16018
|
};
|
|
15905
16019
|
function truncate2(value, limit) {
|
|
@@ -15912,9 +16026,9 @@ function truncate2(value, limit) {
|
|
|
15912
16026
|
|
|
15913
16027
|
// src/commands/LinearCommandHandler.ts
|
|
15914
16028
|
var import_node_child_process8 = require("child_process");
|
|
15915
|
-
var
|
|
15916
|
-
var
|
|
15917
|
-
var
|
|
16029
|
+
var import_node_fs8 = require("fs");
|
|
16030
|
+
var import_node_os3 = __toESM(require("os"));
|
|
16031
|
+
var import_node_path13 = __toESM(require("path"));
|
|
15918
16032
|
var import_promises3 = require("readline/promises");
|
|
15919
16033
|
var import_openai = __toESM(require("openai"));
|
|
15920
16034
|
var import_sdk = require("@linear/sdk");
|
|
@@ -16798,15 +16912,15 @@ var LinearCommandHandler = class {
|
|
|
16798
16912
|
}
|
|
16799
16913
|
}
|
|
16800
16914
|
getLinearSelectionPath() {
|
|
16801
|
-
return
|
|
16915
|
+
return import_node_path13.default.join(import_node_os3.default.homedir(), ".pmate", "linear-selection.json");
|
|
16802
16916
|
}
|
|
16803
16917
|
readCachedLinearSelection(cwd) {
|
|
16804
16918
|
const selectionPath = this.getLinearSelectionPath();
|
|
16805
|
-
if (!(0,
|
|
16919
|
+
if (!(0, import_node_fs8.existsSync)(selectionPath)) {
|
|
16806
16920
|
return void 0;
|
|
16807
16921
|
}
|
|
16808
16922
|
try {
|
|
16809
|
-
const raw = (0,
|
|
16923
|
+
const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
|
|
16810
16924
|
if (!raw) return void 0;
|
|
16811
16925
|
const parsed = JSON.parse(raw);
|
|
16812
16926
|
const value = parsed[cwd];
|
|
@@ -16817,12 +16931,12 @@ var LinearCommandHandler = class {
|
|
|
16817
16931
|
}
|
|
16818
16932
|
writeCachedLinearSelection(cwd, title) {
|
|
16819
16933
|
const selectionPath = this.getLinearSelectionPath();
|
|
16820
|
-
const dir =
|
|
16821
|
-
(0,
|
|
16934
|
+
const dir = import_node_path13.default.dirname(selectionPath);
|
|
16935
|
+
(0, import_node_fs8.mkdirSync)(dir, { recursive: true });
|
|
16822
16936
|
let data = {};
|
|
16823
|
-
if ((0,
|
|
16937
|
+
if ((0, import_node_fs8.existsSync)(selectionPath)) {
|
|
16824
16938
|
try {
|
|
16825
|
-
const raw = (0,
|
|
16939
|
+
const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
|
|
16826
16940
|
if (raw) {
|
|
16827
16941
|
data = JSON.parse(raw);
|
|
16828
16942
|
}
|
|
@@ -16831,7 +16945,7 @@ var LinearCommandHandler = class {
|
|
|
16831
16945
|
}
|
|
16832
16946
|
}
|
|
16833
16947
|
data[cwd] = title;
|
|
16834
|
-
(0,
|
|
16948
|
+
(0, import_node_fs8.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
|
|
16835
16949
|
`, "utf8");
|
|
16836
16950
|
}
|
|
16837
16951
|
async lookupIssue(client, issueRef) {
|
|
@@ -17008,14 +17122,14 @@ var LinearCommandHandler = class {
|
|
|
17008
17122
|
if (process.platform !== "darwin") {
|
|
17009
17123
|
throw new Error("Screenshot capture only supports macOS.");
|
|
17010
17124
|
}
|
|
17011
|
-
const dir = await
|
|
17012
|
-
const filePath =
|
|
17125
|
+
const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os3.default.tmpdir(), "pmate-screenshot-"));
|
|
17126
|
+
const filePath = import_node_path13.default.join(dir, `screenshot-${index}.png`);
|
|
17013
17127
|
try {
|
|
17014
17128
|
const code = await this.run("screencapture", ["-i", "-x", filePath], true);
|
|
17015
17129
|
if (code !== 0) {
|
|
17016
17130
|
throw new Error("Screenshot capture canceled or failed.");
|
|
17017
17131
|
}
|
|
17018
|
-
const buffer = await
|
|
17132
|
+
const buffer = await import_node_fs8.promises.readFile(filePath);
|
|
17019
17133
|
if (buffer.length === 0) {
|
|
17020
17134
|
throw new Error("Screenshot capture produced an empty file.");
|
|
17021
17135
|
}
|
|
@@ -17027,7 +17141,7 @@ var LinearCommandHandler = class {
|
|
|
17027
17141
|
return { buffer, mime, filename: `screenshot-${index}.${extension}` };
|
|
17028
17142
|
} finally {
|
|
17029
17143
|
try {
|
|
17030
|
-
await
|
|
17144
|
+
await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
|
|
17031
17145
|
} catch {
|
|
17032
17146
|
}
|
|
17033
17147
|
}
|
|
@@ -17171,17 +17285,17 @@ var LinearCommandHandler = class {
|
|
|
17171
17285
|
return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
|
|
17172
17286
|
}
|
|
17173
17287
|
async convertToPng(buffer, ext) {
|
|
17174
|
-
const dir = await
|
|
17175
|
-
const inputPath =
|
|
17176
|
-
const outputPath =
|
|
17288
|
+
const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os3.default.tmpdir(), "pmate-"));
|
|
17289
|
+
const inputPath = import_node_path13.default.join(dir, `clipboard.${ext}`);
|
|
17290
|
+
const outputPath = import_node_path13.default.join(dir, "clipboard.png");
|
|
17177
17291
|
try {
|
|
17178
|
-
await
|
|
17292
|
+
await import_node_fs8.promises.writeFile(inputPath, buffer);
|
|
17179
17293
|
const stderr = await this.runCapture(
|
|
17180
17294
|
"sips",
|
|
17181
17295
|
["-s", "format", "png", inputPath, "--out", outputPath],
|
|
17182
17296
|
true
|
|
17183
17297
|
);
|
|
17184
|
-
const out = await
|
|
17298
|
+
const out = await import_node_fs8.promises.readFile(outputPath);
|
|
17185
17299
|
if (this.detectImageMime(out) !== "image/png") {
|
|
17186
17300
|
throw new Error(
|
|
17187
17301
|
stderr?.trim() ? `Failed to convert clipboard ${ext} to PNG: ${stderr.trim()}` : `Failed to convert clipboard ${ext} to PNG.`
|
|
@@ -17190,7 +17304,7 @@ var LinearCommandHandler = class {
|
|
|
17190
17304
|
return out;
|
|
17191
17305
|
} finally {
|
|
17192
17306
|
try {
|
|
17193
|
-
await
|
|
17307
|
+
await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
|
|
17194
17308
|
} catch {
|
|
17195
17309
|
}
|
|
17196
17310
|
}
|
|
@@ -17484,7 +17598,7 @@ var LinearCommandHandler = class {
|
|
|
17484
17598
|
return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
|
|
17485
17599
|
}
|
|
17486
17600
|
resolveCwd(value) {
|
|
17487
|
-
return value ?
|
|
17601
|
+
return value ? import_node_path13.default.resolve(process.cwd(), value) : process.cwd();
|
|
17488
17602
|
}
|
|
17489
17603
|
createOpenAiClient() {
|
|
17490
17604
|
const config = loadPmateConfig();
|
|
@@ -17536,8 +17650,8 @@ function sleep(ms) {
|
|
|
17536
17650
|
}
|
|
17537
17651
|
|
|
17538
17652
|
// src/commands/NotionCommandHandler.ts
|
|
17539
|
-
var
|
|
17540
|
-
var
|
|
17653
|
+
var import_node_fs9 = require("fs");
|
|
17654
|
+
var import_node_path14 = __toESM(require("path"));
|
|
17541
17655
|
|
|
17542
17656
|
// src/services/NotionService.ts
|
|
17543
17657
|
var NotionService = class {
|
|
@@ -17776,9 +17890,9 @@ ${indent}\`\`\``;
|
|
|
17776
17890
|
static richTextToPlain(richText) {
|
|
17777
17891
|
return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
|
|
17778
17892
|
}
|
|
17779
|
-
static async requestJson(
|
|
17893
|
+
static async requestJson(path21, init) {
|
|
17780
17894
|
const token = this.getToken();
|
|
17781
|
-
const response = await fetch(`${this.baseUrl}${
|
|
17895
|
+
const response = await fetch(`${this.baseUrl}${path21}`, {
|
|
17782
17896
|
method: init.method,
|
|
17783
17897
|
headers: {
|
|
17784
17898
|
Authorization: `Bearer ${token}`,
|
|
@@ -17876,16 +17990,16 @@ var NotionCommandHandler = class {
|
|
|
17876
17990
|
if (!args.filePath) {
|
|
17877
17991
|
return "";
|
|
17878
17992
|
}
|
|
17879
|
-
const resolved =
|
|
17880
|
-
return (0,
|
|
17993
|
+
const resolved = import_node_path14.default.resolve(process.cwd(), args.filePath);
|
|
17994
|
+
return (0, import_node_fs9.readFileSync)(resolved, "utf8");
|
|
17881
17995
|
}
|
|
17882
17996
|
};
|
|
17883
17997
|
|
|
17884
17998
|
// src/commands/QrcodeCommandHandler.ts
|
|
17885
17999
|
var import_node_child_process9 = require("child_process");
|
|
17886
|
-
var
|
|
17887
|
-
var
|
|
17888
|
-
var
|
|
18000
|
+
var import_node_fs10 = require("fs");
|
|
18001
|
+
var import_node_os4 = __toESM(require("os"));
|
|
18002
|
+
var import_node_path15 = __toESM(require("path"));
|
|
17889
18003
|
var import_promises4 = require("readline/promises");
|
|
17890
18004
|
var import_jsqr = __toESM(require("jsqr"));
|
|
17891
18005
|
var import_pngjs = require("pngjs");
|
|
@@ -17911,7 +18025,7 @@ var QrcodeCommandHandler = class {
|
|
|
17911
18025
|
ui.success("QR code value:", value);
|
|
17912
18026
|
} finally {
|
|
17913
18027
|
try {
|
|
17914
|
-
await
|
|
18028
|
+
await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
|
|
17915
18029
|
} catch {
|
|
17916
18030
|
}
|
|
17917
18031
|
}
|
|
@@ -17927,13 +18041,13 @@ var QrcodeCommandHandler = class {
|
|
|
17927
18041
|
} finally {
|
|
17928
18042
|
rl.close();
|
|
17929
18043
|
}
|
|
17930
|
-
const dir = await
|
|
17931
|
-
const filePath =
|
|
18044
|
+
const dir = await import_node_fs10.promises.mkdtemp(import_node_path15.default.join(import_node_os4.default.tmpdir(), "pmate-qrcode-"));
|
|
18045
|
+
const filePath = import_node_path15.default.join(dir, "qrcode.png");
|
|
17932
18046
|
const code = await this.run("screencapture", ["-i", "-x", filePath], true);
|
|
17933
18047
|
if (code !== 0) {
|
|
17934
18048
|
throw new Error("Screenshot capture canceled or failed.");
|
|
17935
18049
|
}
|
|
17936
|
-
const buffer = await
|
|
18050
|
+
const buffer = await import_node_fs10.promises.readFile(filePath);
|
|
17937
18051
|
if (buffer.length === 0) {
|
|
17938
18052
|
throw new Error("Screenshot capture produced an empty file.");
|
|
17939
18053
|
}
|
|
@@ -17949,7 +18063,7 @@ var QrcodeCommandHandler = class {
|
|
|
17949
18063
|
async decodeQr(filePath) {
|
|
17950
18064
|
let buffer;
|
|
17951
18065
|
try {
|
|
17952
|
-
buffer = await
|
|
18066
|
+
buffer = await import_node_fs10.promises.readFile(filePath);
|
|
17953
18067
|
} catch {
|
|
17954
18068
|
return null;
|
|
17955
18069
|
}
|
|
@@ -18209,9 +18323,9 @@ function clampNumber(value, min, max, fallback) {
|
|
|
18209
18323
|
// src/commands/CollectCommandHandler.ts
|
|
18210
18324
|
var import_playwright = require("playwright");
|
|
18211
18325
|
var import_node_crypto3 = require("crypto");
|
|
18212
|
-
var
|
|
18213
|
-
var
|
|
18214
|
-
var
|
|
18326
|
+
var import_node_fs11 = require("fs");
|
|
18327
|
+
var import_node_os5 = __toESM(require("os"));
|
|
18328
|
+
var import_node_path16 = __toESM(require("path"));
|
|
18215
18329
|
var CollectCommandHandler = class {
|
|
18216
18330
|
async handle(args) {
|
|
18217
18331
|
let browser = null;
|
|
@@ -18578,19 +18692,19 @@ function computeMessageHash(threadName, message) {
|
|
|
18578
18692
|
return (0, import_node_crypto3.createHash)("sha1").update(base).digest("hex").slice(0, 16);
|
|
18579
18693
|
}
|
|
18580
18694
|
async function toDisplayableImagePath(src) {
|
|
18581
|
-
if (!
|
|
18695
|
+
if (!import_node_path16.default.isAbsolute(src)) {
|
|
18582
18696
|
return src;
|
|
18583
18697
|
}
|
|
18584
|
-
const ext =
|
|
18698
|
+
const ext = import_node_path16.default.extname(src);
|
|
18585
18699
|
if (ext) {
|
|
18586
18700
|
return src;
|
|
18587
18701
|
}
|
|
18588
18702
|
try {
|
|
18589
|
-
const stat = await
|
|
18703
|
+
const stat = await import_node_fs11.promises.stat(src);
|
|
18590
18704
|
if (!stat.isFile()) {
|
|
18591
18705
|
return src;
|
|
18592
18706
|
}
|
|
18593
|
-
const fh = await
|
|
18707
|
+
const fh = await import_node_fs11.promises.open(src, "r");
|
|
18594
18708
|
try {
|
|
18595
18709
|
const buf = Buffer.alloc(32);
|
|
18596
18710
|
const { bytesRead } = await fh.read(buf, 0, 32, 0);
|
|
@@ -18599,17 +18713,17 @@ async function toDisplayableImagePath(src) {
|
|
|
18599
18713
|
if (!guessedExt) {
|
|
18600
18714
|
return src;
|
|
18601
18715
|
}
|
|
18602
|
-
const cacheDir =
|
|
18603
|
-
|
|
18716
|
+
const cacheDir = import_node_path16.default.join(
|
|
18717
|
+
import_node_os5.default.homedir(),
|
|
18604
18718
|
".pmate",
|
|
18605
18719
|
"messages",
|
|
18606
18720
|
"images"
|
|
18607
18721
|
);
|
|
18608
|
-
await
|
|
18722
|
+
await import_node_fs11.promises.mkdir(cacheDir, { recursive: true });
|
|
18609
18723
|
const base = (0, import_node_crypto3.createHash)("sha1").update(src).digest("hex");
|
|
18610
|
-
const displayPath =
|
|
18611
|
-
await
|
|
18612
|
-
await
|
|
18724
|
+
const displayPath = import_node_path16.default.join(cacheDir, `${base}.${guessedExt}`);
|
|
18725
|
+
await import_node_fs11.promises.rm(displayPath, { force: true }).catch(() => void 0);
|
|
18726
|
+
await import_node_fs11.promises.copyFile(src, displayPath);
|
|
18613
18727
|
return displayPath;
|
|
18614
18728
|
} finally {
|
|
18615
18729
|
await fh.close();
|
|
@@ -18665,9 +18779,9 @@ function parseMessageText(raw) {
|
|
|
18665
18779
|
}
|
|
18666
18780
|
|
|
18667
18781
|
// src/commands/AgentCommandHandler.ts
|
|
18668
|
-
var
|
|
18669
|
-
var
|
|
18670
|
-
|
|
18782
|
+
var import_node_fs12 = require("fs");
|
|
18783
|
+
var import_node_path17 = __toESM(require("path"));
|
|
18784
|
+
init_sessionStore();
|
|
18671
18785
|
var AgentCommandHandler = class {
|
|
18672
18786
|
async handle(args) {
|
|
18673
18787
|
const token = this.readToken();
|
|
@@ -18749,24 +18863,16 @@ var AgentCommandHandler = class {
|
|
|
18749
18863
|
);
|
|
18750
18864
|
}
|
|
18751
18865
|
readToken() {
|
|
18752
|
-
|
|
18753
|
-
|
|
18754
|
-
|
|
18755
|
-
}
|
|
18756
|
-
const raw = (0, import_node_fs14.readFileSync)(sessionPath, "utf8");
|
|
18757
|
-
const parsed = JSON.parse(raw);
|
|
18758
|
-
const token = parsed.token?.trim();
|
|
18759
|
-
if (!token) {
|
|
18760
|
-
throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
|
|
18761
|
-
}
|
|
18762
|
-
return token;
|
|
18866
|
+
return readRequiredSession({
|
|
18867
|
+
preferredApp: DEFAULT_APP_ID
|
|
18868
|
+
}).token;
|
|
18763
18869
|
}
|
|
18764
18870
|
readJsonFile(filePath) {
|
|
18765
|
-
const absolutePath =
|
|
18766
|
-
if (!(0,
|
|
18871
|
+
const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
|
|
18872
|
+
if (!(0, import_node_fs12.existsSync)(absolutePath)) {
|
|
18767
18873
|
throw new Error(`JSON file not found: ${absolutePath}`);
|
|
18768
18874
|
}
|
|
18769
|
-
const raw = (0,
|
|
18875
|
+
const raw = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
|
|
18770
18876
|
try {
|
|
18771
18877
|
return JSON.parse(raw);
|
|
18772
18878
|
} catch (error) {
|
|
@@ -18834,10 +18940,407 @@ var AgentCommandHandler = class {
|
|
|
18834
18940
|
}
|
|
18835
18941
|
};
|
|
18836
18942
|
|
|
18943
|
+
// src/commands/StoreCommandHandler.ts
|
|
18944
|
+
var import_node_fs13 = require("fs");
|
|
18945
|
+
var import_node_path18 = __toESM(require("path"));
|
|
18946
|
+
|
|
18947
|
+
// src/storeClient.ts
|
|
18948
|
+
var STORE_LOG_VERSION = 1;
|
|
18949
|
+
var LOG_KIND_TABLE = 1e4;
|
|
18950
|
+
var LOG_KIND_MAPPING = 6003;
|
|
18951
|
+
function createHash3() {
|
|
18952
|
+
return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
|
|
18953
|
+
}
|
|
18954
|
+
function createDescriptor(input) {
|
|
18955
|
+
for (const [label, value] of Object.entries({
|
|
18956
|
+
chain: input.chain,
|
|
18957
|
+
namespace: input.ns,
|
|
18958
|
+
kind: input.kind,
|
|
18959
|
+
name: input.name
|
|
18960
|
+
})) {
|
|
18961
|
+
if (!value || value.includes("/")) {
|
|
18962
|
+
throw new Error(`Invalid ${label} "${value}". ${label} must be non-empty and cannot contain "/".`);
|
|
18963
|
+
}
|
|
18964
|
+
}
|
|
18965
|
+
return { ...input };
|
|
18966
|
+
}
|
|
18967
|
+
function descriptorToTopic(descriptor) {
|
|
18968
|
+
const normalized = createDescriptor(descriptor);
|
|
18969
|
+
return `@${normalized.ns}/${normalized.name}`;
|
|
18970
|
+
}
|
|
18971
|
+
function descriptorPathSegments(descriptor) {
|
|
18972
|
+
const normalized = createDescriptor(descriptor);
|
|
18973
|
+
return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
|
|
18974
|
+
}
|
|
18975
|
+
function buildPathUrl(baseUrl, pathSegments, query) {
|
|
18976
|
+
const path21 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
|
|
18977
|
+
const url = new URL(path21, baseUrl);
|
|
18978
|
+
if (query) {
|
|
18979
|
+
for (const [key, value] of Object.entries(query)) {
|
|
18980
|
+
url.searchParams.set(key, String(value));
|
|
18981
|
+
}
|
|
18982
|
+
}
|
|
18983
|
+
return url.toString();
|
|
18984
|
+
}
|
|
18985
|
+
async function requestJson(url, init, fallbackMessage) {
|
|
18986
|
+
const response = await fetch(url, init);
|
|
18987
|
+
const payload = await response.json();
|
|
18988
|
+
if (!response.ok || !payload?.success) {
|
|
18989
|
+
throw new Error(payload?.message || `${fallbackMessage}: ${response.status}`);
|
|
18990
|
+
}
|
|
18991
|
+
return payload;
|
|
18992
|
+
}
|
|
18993
|
+
var IndexerClient = class {
|
|
18994
|
+
constructor(baseUrl) {
|
|
18995
|
+
this.baseUrl = baseUrl;
|
|
18996
|
+
}
|
|
18997
|
+
async requestByPath(pathSegments, options = {}) {
|
|
18998
|
+
const method = options.method ?? "GET";
|
|
18999
|
+
const url = buildPathUrl(this.baseUrl, pathSegments, method === "GET" ? options.query : void 0);
|
|
19000
|
+
const payload = await requestJson(
|
|
19001
|
+
url,
|
|
19002
|
+
{
|
|
19003
|
+
method,
|
|
19004
|
+
headers: {
|
|
19005
|
+
Accept: "application/json",
|
|
19006
|
+
...method === "POST" ? { "Content-Type": "application/json" } : {}
|
|
19007
|
+
},
|
|
19008
|
+
...method === "POST" ? { body: JSON.stringify(options.query ?? {}) } : {}
|
|
19009
|
+
},
|
|
19010
|
+
"Indexer request failed"
|
|
19011
|
+
);
|
|
19012
|
+
return payload.data;
|
|
19013
|
+
}
|
|
19014
|
+
};
|
|
19015
|
+
var BlockLogAppender = class {
|
|
19016
|
+
constructor(chainId, baseUrl) {
|
|
19017
|
+
this.chainId = chainId;
|
|
19018
|
+
this.baseUrl = baseUrl;
|
|
19019
|
+
}
|
|
19020
|
+
async append(logs) {
|
|
19021
|
+
if (!logs.length) return;
|
|
19022
|
+
const url = `${this.baseUrl.replace(/\/+$/, "")}/chains/${encodeURIComponent(this.chainId)}/logs`;
|
|
19023
|
+
await fetch(url, {
|
|
19024
|
+
method: "POST",
|
|
19025
|
+
headers: {
|
|
19026
|
+
"Content-Type": "application/json",
|
|
19027
|
+
...process.env.TSDB_BEARER_TOKEN ? { authorization: `Bearer ${process.env.TSDB_BEARER_TOKEN}` } : {}
|
|
19028
|
+
},
|
|
19029
|
+
body: JSON.stringify({ logs })
|
|
19030
|
+
}).then(async (response) => {
|
|
19031
|
+
if (!response.ok) {
|
|
19032
|
+
throw new Error(`TSDB request failed: ${response.status} ${response.statusText}`);
|
|
19033
|
+
}
|
|
19034
|
+
});
|
|
19035
|
+
}
|
|
19036
|
+
};
|
|
19037
|
+
var Namespace = class {
|
|
19038
|
+
constructor(options) {
|
|
19039
|
+
this.options = options;
|
|
19040
|
+
this.appender = new BlockLogAppender(options.chain, options.baseUrl.replace(/\/+$/, ""));
|
|
19041
|
+
this.indexerClient = new IndexerClient(options.indexerBaseUrl.replace(/\/+$/, ""));
|
|
19042
|
+
}
|
|
19043
|
+
table(name) {
|
|
19044
|
+
const descriptor = createDescriptor({
|
|
19045
|
+
chain: this.options.chain,
|
|
19046
|
+
ns: this.options.ns,
|
|
19047
|
+
kind: "table",
|
|
19048
|
+
name
|
|
19049
|
+
});
|
|
19050
|
+
return {
|
|
19051
|
+
list: async (pageNo = 0) => {
|
|
19052
|
+
const data = await this.indexerClient.requestByPath(
|
|
19053
|
+
[...descriptorPathSegments(descriptor), "page"],
|
|
19054
|
+
{ query: { page_id: pageNo } }
|
|
19055
|
+
);
|
|
19056
|
+
if (!data) return [];
|
|
19057
|
+
if (Array.isArray(data)) return data;
|
|
19058
|
+
return Array.isArray(data.data) ? data.data : [];
|
|
19059
|
+
},
|
|
19060
|
+
getById: async (id) => {
|
|
19061
|
+
const data = await this.indexerClient.requestByPath(
|
|
19062
|
+
[...descriptorPathSegments(descriptor), "get_by_id"],
|
|
19063
|
+
{ query: { id } }
|
|
19064
|
+
);
|
|
19065
|
+
return data ?? void 0;
|
|
19066
|
+
},
|
|
19067
|
+
exists: async (id) => {
|
|
19068
|
+
const data = await this.indexerClient.requestByPath(
|
|
19069
|
+
[...descriptorPathSegments(descriptor), "exists"],
|
|
19070
|
+
{ query: { id } }
|
|
19071
|
+
);
|
|
19072
|
+
return Boolean(data);
|
|
19073
|
+
},
|
|
19074
|
+
appendRow: async (data) => {
|
|
19075
|
+
const log = {
|
|
19076
|
+
hash: createHash3(),
|
|
19077
|
+
t: Date.now(),
|
|
19078
|
+
kind: LOG_KIND_TABLE,
|
|
19079
|
+
topic: descriptorToTopic(descriptor),
|
|
19080
|
+
v: STORE_LOG_VERSION,
|
|
19081
|
+
data: { type: "create", after: data }
|
|
19082
|
+
};
|
|
19083
|
+
await this.appender.append([log]);
|
|
19084
|
+
},
|
|
19085
|
+
updateRow: async (data) => {
|
|
19086
|
+
const { id, ...value } = data;
|
|
19087
|
+
const log = {
|
|
19088
|
+
hash: createHash3(),
|
|
19089
|
+
t: Date.now(),
|
|
19090
|
+
kind: LOG_KIND_TABLE,
|
|
19091
|
+
topic: descriptorToTopic(descriptor),
|
|
19092
|
+
v: STORE_LOG_VERSION,
|
|
19093
|
+
data: { type: "update", id, value }
|
|
19094
|
+
};
|
|
19095
|
+
await this.appender.append([log]);
|
|
19096
|
+
},
|
|
19097
|
+
deleteRow: async (id) => {
|
|
19098
|
+
const log = {
|
|
19099
|
+
hash: createHash3(),
|
|
19100
|
+
t: Date.now(),
|
|
19101
|
+
kind: LOG_KIND_TABLE,
|
|
19102
|
+
topic: descriptorToTopic(descriptor),
|
|
19103
|
+
v: STORE_LOG_VERSION,
|
|
19104
|
+
data: { type: "delete", id }
|
|
19105
|
+
};
|
|
19106
|
+
await this.appender.append([log]);
|
|
19107
|
+
}
|
|
19108
|
+
};
|
|
19109
|
+
}
|
|
19110
|
+
kv(name) {
|
|
19111
|
+
const descriptor = createDescriptor({
|
|
19112
|
+
chain: this.options.chain,
|
|
19113
|
+
ns: this.options.ns,
|
|
19114
|
+
kind: "kv",
|
|
19115
|
+
name
|
|
19116
|
+
});
|
|
19117
|
+
return {
|
|
19118
|
+
list: async (pageNo = 0) => {
|
|
19119
|
+
const data = await this.indexerClient.requestByPath([...descriptorPathSegments(descriptor), "page"], {
|
|
19120
|
+
query: { page_id: pageNo }
|
|
19121
|
+
});
|
|
19122
|
+
if (!data) return [];
|
|
19123
|
+
if (Array.isArray(data)) return data;
|
|
19124
|
+
return Array.isArray(data.data) ? data.data : [];
|
|
19125
|
+
},
|
|
19126
|
+
get: async (key) => {
|
|
19127
|
+
const data = await this.indexerClient.requestByPath(
|
|
19128
|
+
[...descriptorPathSegments(descriptor), "get"],
|
|
19129
|
+
{ query: { key } }
|
|
19130
|
+
);
|
|
19131
|
+
return data ?? void 0;
|
|
19132
|
+
},
|
|
19133
|
+
exists: async (key) => {
|
|
19134
|
+
const data = await this.indexerClient.requestByPath(
|
|
19135
|
+
[...descriptorPathSegments(descriptor), "exists"],
|
|
19136
|
+
{ query: { key } }
|
|
19137
|
+
);
|
|
19138
|
+
return Boolean(data);
|
|
19139
|
+
},
|
|
19140
|
+
set: async (key, value) => {
|
|
19141
|
+
const log = {
|
|
19142
|
+
hash: createHash3(),
|
|
19143
|
+
t: Date.now(),
|
|
19144
|
+
kind: LOG_KIND_MAPPING,
|
|
19145
|
+
topic: descriptorToTopic(descriptor),
|
|
19146
|
+
v: STORE_LOG_VERSION,
|
|
19147
|
+
data: { key, value }
|
|
19148
|
+
};
|
|
19149
|
+
await this.appender.append([log]);
|
|
19150
|
+
},
|
|
19151
|
+
delete: async (key) => {
|
|
19152
|
+
const log = {
|
|
19153
|
+
hash: createHash3(),
|
|
19154
|
+
t: Date.now(),
|
|
19155
|
+
kind: LOG_KIND_MAPPING,
|
|
19156
|
+
topic: descriptorToTopic(descriptor),
|
|
19157
|
+
v: STORE_LOG_VERSION,
|
|
19158
|
+
data: { key, value: null }
|
|
19159
|
+
};
|
|
19160
|
+
await this.appender.append([log]);
|
|
19161
|
+
}
|
|
19162
|
+
};
|
|
19163
|
+
}
|
|
19164
|
+
};
|
|
19165
|
+
|
|
19166
|
+
// src/commands/StoreCommandHandler.ts
|
|
19167
|
+
var StoreCommandHandler = class {
|
|
19168
|
+
async handle(args) {
|
|
19169
|
+
if (args.scope === "namespace") {
|
|
19170
|
+
const items = await this.listNamespaces(args);
|
|
19171
|
+
this.renderNamespaceList(items, args.json);
|
|
19172
|
+
return;
|
|
19173
|
+
}
|
|
19174
|
+
const namespace = this.createNamespace(args);
|
|
19175
|
+
if (args.scope === "table") {
|
|
19176
|
+
const table = namespace.table(args.name);
|
|
19177
|
+
switch (args.action) {
|
|
19178
|
+
case "list": {
|
|
19179
|
+
const rows = await table.list(args.page);
|
|
19180
|
+
this.renderJsonOrSummary(
|
|
19181
|
+
rows,
|
|
19182
|
+
args.json,
|
|
19183
|
+
"No rows found.",
|
|
19184
|
+
(row) => row.id ?? "<missing-id>"
|
|
19185
|
+
);
|
|
19186
|
+
return;
|
|
19187
|
+
}
|
|
19188
|
+
case "get": {
|
|
19189
|
+
const row = await table.getById(args.id);
|
|
19190
|
+
this.renderValue(row, args.json);
|
|
19191
|
+
return;
|
|
19192
|
+
}
|
|
19193
|
+
case "exists": {
|
|
19194
|
+
const exists = await table.exists(args.id);
|
|
19195
|
+
this.renderValue(exists, args.json);
|
|
19196
|
+
return;
|
|
19197
|
+
}
|
|
19198
|
+
case "delete": {
|
|
19199
|
+
await table.deleteRow(args.id);
|
|
19200
|
+
ui.success(`Deleted row ${args.name}/${args.id}`);
|
|
19201
|
+
return;
|
|
19202
|
+
}
|
|
19203
|
+
case "create": {
|
|
19204
|
+
const payload = this.readJsonFile(args.filePath);
|
|
19205
|
+
await table.appendRow(payload);
|
|
19206
|
+
ui.success(`Created row in ${args.name}`, { filePath: args.filePath });
|
|
19207
|
+
return;
|
|
19208
|
+
}
|
|
19209
|
+
case "update": {
|
|
19210
|
+
const payload = this.readJsonFile(args.filePath);
|
|
19211
|
+
await table.updateRow(payload);
|
|
19212
|
+
ui.success(`Updated row in ${args.name}`, { filePath: args.filePath });
|
|
19213
|
+
return;
|
|
19214
|
+
}
|
|
19215
|
+
}
|
|
19216
|
+
}
|
|
19217
|
+
const kv = namespace.kv(args.name);
|
|
19218
|
+
switch (args.action) {
|
|
19219
|
+
case "list": {
|
|
19220
|
+
const rows = await kv.list(args.page);
|
|
19221
|
+
this.renderJsonOrSummary(
|
|
19222
|
+
rows,
|
|
19223
|
+
args.json,
|
|
19224
|
+
"No kv entries found.",
|
|
19225
|
+
(row) => row.key
|
|
19226
|
+
);
|
|
19227
|
+
return;
|
|
19228
|
+
}
|
|
19229
|
+
case "get": {
|
|
19230
|
+
const value = await kv.get(args.key);
|
|
19231
|
+
this.renderValue(value, args.json);
|
|
19232
|
+
return;
|
|
19233
|
+
}
|
|
19234
|
+
case "exists": {
|
|
19235
|
+
const exists = await kv.exists(args.key);
|
|
19236
|
+
this.renderValue(exists, args.json);
|
|
19237
|
+
return;
|
|
19238
|
+
}
|
|
19239
|
+
case "delete": {
|
|
19240
|
+
await kv.delete(args.key);
|
|
19241
|
+
ui.success(`Deleted key ${args.name}/${args.key}`);
|
|
19242
|
+
return;
|
|
19243
|
+
}
|
|
19244
|
+
case "set": {
|
|
19245
|
+
const value = args.filePath ? this.readJsonFile(args.filePath) : JSON.parse(args.value);
|
|
19246
|
+
await kv.set(args.key, value);
|
|
19247
|
+
ui.success(`Set key ${args.name}/${args.key}`);
|
|
19248
|
+
return;
|
|
19249
|
+
}
|
|
19250
|
+
}
|
|
19251
|
+
}
|
|
19252
|
+
createNamespace(args) {
|
|
19253
|
+
return new Namespace({
|
|
19254
|
+
chain: args.chain,
|
|
19255
|
+
ns: args.namespace,
|
|
19256
|
+
baseUrl: this.resolveBaseUrl(args.baseUrl),
|
|
19257
|
+
indexerBaseUrl: this.resolveIndexerBaseUrl(args.indexerBaseUrl)
|
|
19258
|
+
});
|
|
19259
|
+
}
|
|
19260
|
+
resolveBaseUrl(baseUrl) {
|
|
19261
|
+
const resolved = baseUrl || process.env.PMATE_STORE_BASE_URL || process.env.BLOCKCHAIN_BASE_URL;
|
|
19262
|
+
if (!resolved) {
|
|
19263
|
+
throw new Error(
|
|
19264
|
+
"Missing store base URL. Provide --base-url or set PMATE_STORE_BASE_URL / BLOCKCHAIN_BASE_URL."
|
|
19265
|
+
);
|
|
19266
|
+
}
|
|
19267
|
+
return resolved.replace(/\/+$/, "");
|
|
19268
|
+
}
|
|
19269
|
+
resolveIndexerBaseUrl(indexerBaseUrl) {
|
|
19270
|
+
return (indexerBaseUrl || process.env.PMATE_STORE_INDEXER_BASE_URL || process.env.INDEXER_BASE_URL || "https://indexer.pmate.chat").replace(/\/+$/, "");
|
|
19271
|
+
}
|
|
19272
|
+
async listNamespaces(args) {
|
|
19273
|
+
const baseUrl = this.resolveIndexerBaseUrl(args.indexerBaseUrl);
|
|
19274
|
+
const url = new URL(`/chains/${encodeURIComponent(args.chain)}/namespaces`, `${baseUrl}/`);
|
|
19275
|
+
const response = await fetch(url.toString(), {
|
|
19276
|
+
headers: { Accept: "application/json" }
|
|
19277
|
+
});
|
|
19278
|
+
const payload = await response.json();
|
|
19279
|
+
if (!response.ok || !payload?.success) {
|
|
19280
|
+
throw new Error(payload?.message || `Namespace list request failed with status ${response.status}`);
|
|
19281
|
+
}
|
|
19282
|
+
return payload.data ?? [];
|
|
19283
|
+
}
|
|
19284
|
+
readJsonFile(filePath) {
|
|
19285
|
+
const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
|
|
19286
|
+
if (!(0, import_node_fs13.existsSync)(absolutePath)) {
|
|
19287
|
+
throw new Error(`JSON file not found: ${absolutePath}`);
|
|
19288
|
+
}
|
|
19289
|
+
const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
|
|
19290
|
+
try {
|
|
19291
|
+
return JSON.parse(raw);
|
|
19292
|
+
} catch (error) {
|
|
19293
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
19294
|
+
throw new Error(`Invalid JSON in ${absolutePath}: ${message}`);
|
|
19295
|
+
}
|
|
19296
|
+
}
|
|
19297
|
+
renderNamespaceList(items, asJson) {
|
|
19298
|
+
if (asJson) {
|
|
19299
|
+
ui.plain(JSON.stringify(items, null, 2));
|
|
19300
|
+
return;
|
|
19301
|
+
}
|
|
19302
|
+
if (items.length === 0) {
|
|
19303
|
+
ui.warn("No namespaces found.");
|
|
19304
|
+
return;
|
|
19305
|
+
}
|
|
19306
|
+
for (const item of items) {
|
|
19307
|
+
ui.info(`${item.chain}/${item.namespace}`);
|
|
19308
|
+
}
|
|
19309
|
+
}
|
|
19310
|
+
renderJsonOrSummary(items, asJson, emptyText, label) {
|
|
19311
|
+
if (asJson) {
|
|
19312
|
+
ui.plain(JSON.stringify(items, null, 2));
|
|
19313
|
+
return;
|
|
19314
|
+
}
|
|
19315
|
+
if (items.length === 0) {
|
|
19316
|
+
ui.warn(emptyText);
|
|
19317
|
+
return;
|
|
19318
|
+
}
|
|
19319
|
+
for (const item of items) {
|
|
19320
|
+
ui.info(label(item), item);
|
|
19321
|
+
}
|
|
19322
|
+
}
|
|
19323
|
+
renderValue(value, asJson) {
|
|
19324
|
+
if (asJson) {
|
|
19325
|
+
ui.plain(JSON.stringify(value ?? null, null, 2));
|
|
19326
|
+
return;
|
|
19327
|
+
}
|
|
19328
|
+
if (typeof value === "boolean") {
|
|
19329
|
+
ui.plain(String(value));
|
|
19330
|
+
return;
|
|
19331
|
+
}
|
|
19332
|
+
if (value == null) {
|
|
19333
|
+
ui.warn("Not found.");
|
|
19334
|
+
return;
|
|
19335
|
+
}
|
|
19336
|
+
ui.plain(JSON.stringify(value, null, 2));
|
|
19337
|
+
}
|
|
19338
|
+
};
|
|
19339
|
+
|
|
18837
19340
|
// src/commands/AppCommandHandler.ts
|
|
18838
|
-
var
|
|
18839
|
-
var
|
|
18840
|
-
|
|
19341
|
+
var import_node_fs14 = require("fs");
|
|
19342
|
+
var import_node_path19 = __toESM(require("path"));
|
|
19343
|
+
init_sessionStore();
|
|
18841
19344
|
var AppCommandHandler = class {
|
|
18842
19345
|
async handle(args) {
|
|
18843
19346
|
const token = this.readToken();
|
|
@@ -18906,24 +19409,16 @@ var AppCommandHandler = class {
|
|
|
18906
19409
|
return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
|
|
18907
19410
|
}
|
|
18908
19411
|
readToken() {
|
|
18909
|
-
|
|
18910
|
-
|
|
18911
|
-
|
|
18912
|
-
}
|
|
18913
|
-
const raw = (0, import_node_fs15.readFileSync)(sessionPath, "utf8");
|
|
18914
|
-
const parsed = JSON.parse(raw);
|
|
18915
|
-
const token = parsed.token?.trim();
|
|
18916
|
-
if (!token) {
|
|
18917
|
-
throw new Error(`Missing token in ${sessionPath}. Run "pmate login" again.`);
|
|
18918
|
-
}
|
|
18919
|
-
return token;
|
|
19412
|
+
return readRequiredSession({
|
|
19413
|
+
preferredApp: DEFAULT_APP_ID
|
|
19414
|
+
}).token;
|
|
18920
19415
|
}
|
|
18921
19416
|
readJsonFile(filePath) {
|
|
18922
|
-
const absolutePath =
|
|
18923
|
-
if (!(0,
|
|
19417
|
+
const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
|
|
19418
|
+
if (!(0, import_node_fs14.existsSync)(absolutePath)) {
|
|
18924
19419
|
throw new Error(`JSON file not found: ${absolutePath}`);
|
|
18925
19420
|
}
|
|
18926
|
-
const raw = (0,
|
|
19421
|
+
const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
|
|
18927
19422
|
try {
|
|
18928
19423
|
return JSON.parse(raw);
|
|
18929
19424
|
} catch (error) {
|
|
@@ -19091,7 +19586,7 @@ function parseAgentArgs(tokens) {
|
|
|
19091
19586
|
}
|
|
19092
19587
|
let baseUrl;
|
|
19093
19588
|
let json = false;
|
|
19094
|
-
const
|
|
19589
|
+
const takeSharedOptions2 = () => {
|
|
19095
19590
|
while (rest.length > 0) {
|
|
19096
19591
|
const token = rest[0];
|
|
19097
19592
|
if (token === "--base-url") {
|
|
@@ -19108,7 +19603,7 @@ function parseAgentArgs(tokens) {
|
|
|
19108
19603
|
}
|
|
19109
19604
|
};
|
|
19110
19605
|
if (action === "namespaces") {
|
|
19111
|
-
|
|
19606
|
+
takeSharedOptions2();
|
|
19112
19607
|
if (rest.length > 0) {
|
|
19113
19608
|
throw new Error(`Unknown agent namespaces option: ${rest[0]}`);
|
|
19114
19609
|
}
|
|
@@ -19150,7 +19645,7 @@ function parseAgentArgs(tokens) {
|
|
|
19150
19645
|
`Usage: agent ${action} [<namespace>] <name> [--base-url <url>] [--json]`
|
|
19151
19646
|
);
|
|
19152
19647
|
}
|
|
19153
|
-
|
|
19648
|
+
takeSharedOptions2();
|
|
19154
19649
|
if (rest.length > 0) {
|
|
19155
19650
|
throw new Error(`Unknown agent ${action} option: ${rest[0]}`);
|
|
19156
19651
|
}
|
|
@@ -19231,6 +19726,213 @@ function requireValue(tokens, optionName) {
|
|
|
19231
19726
|
return value;
|
|
19232
19727
|
}
|
|
19233
19728
|
|
|
19729
|
+
// src/storeCommandParser.ts
|
|
19730
|
+
var DEFAULT_CHAIN = "pmate";
|
|
19731
|
+
var DEFAULT_NAMESPACE2 = "pmate";
|
|
19732
|
+
function parseStoreArgs(tokens) {
|
|
19733
|
+
const rest = [...tokens];
|
|
19734
|
+
const scope = rest.shift();
|
|
19735
|
+
if (!scope) {
|
|
19736
|
+
throw new Error("Missing store scope. Use: store namespace|table|kv");
|
|
19737
|
+
}
|
|
19738
|
+
const action = rest.shift();
|
|
19739
|
+
if (!action) {
|
|
19740
|
+
throw new Error(`Missing store ${scope} action.`);
|
|
19741
|
+
}
|
|
19742
|
+
const shared = {
|
|
19743
|
+
chain: DEFAULT_CHAIN,
|
|
19744
|
+
namespace: DEFAULT_NAMESPACE2,
|
|
19745
|
+
baseUrl: void 0,
|
|
19746
|
+
indexerBaseUrl: void 0,
|
|
19747
|
+
json: false
|
|
19748
|
+
};
|
|
19749
|
+
if (scope === "namespace") {
|
|
19750
|
+
if (action !== "list") {
|
|
19751
|
+
throw new Error(`Unknown store namespace action: ${action}`);
|
|
19752
|
+
}
|
|
19753
|
+
takeSharedOptions(rest, shared);
|
|
19754
|
+
if (rest.length > 0) {
|
|
19755
|
+
throw new Error(`Unknown store namespace option: ${rest[0]}`);
|
|
19756
|
+
}
|
|
19757
|
+
return {
|
|
19758
|
+
type: "store" /* Store */,
|
|
19759
|
+
scope,
|
|
19760
|
+
action,
|
|
19761
|
+
...shared
|
|
19762
|
+
};
|
|
19763
|
+
}
|
|
19764
|
+
if (scope === "table") {
|
|
19765
|
+
return parseTableArgs(action, rest, shared);
|
|
19766
|
+
}
|
|
19767
|
+
if (scope === "kv") {
|
|
19768
|
+
return parseKvArgs(action, rest, shared);
|
|
19769
|
+
}
|
|
19770
|
+
throw new Error(`Unknown store scope: ${scope}`);
|
|
19771
|
+
}
|
|
19772
|
+
function parseTableArgs(action, rest, shared) {
|
|
19773
|
+
const name = rest.shift();
|
|
19774
|
+
if (!name || name.startsWith("-")) {
|
|
19775
|
+
throw new Error(`Missing table name. Usage: store table ${action} <name> ...`);
|
|
19776
|
+
}
|
|
19777
|
+
if (action === "list") {
|
|
19778
|
+
let page = 0;
|
|
19779
|
+
while (rest.length > 0) {
|
|
19780
|
+
const token = rest.shift();
|
|
19781
|
+
switch (token) {
|
|
19782
|
+
case "--page":
|
|
19783
|
+
page = parsePage(requireValue2(rest, token));
|
|
19784
|
+
break;
|
|
19785
|
+
default:
|
|
19786
|
+
pushSharedOption(token, rest, shared);
|
|
19787
|
+
}
|
|
19788
|
+
}
|
|
19789
|
+
return { type: "store" /* Store */, scope: "table", action, name, page, ...shared };
|
|
19790
|
+
}
|
|
19791
|
+
if (action === "get" || action === "exists" || action === "delete") {
|
|
19792
|
+
let id;
|
|
19793
|
+
while (rest.length > 0) {
|
|
19794
|
+
const token = rest.shift();
|
|
19795
|
+
switch (token) {
|
|
19796
|
+
case "--id":
|
|
19797
|
+
id = requireValue2(rest, token);
|
|
19798
|
+
break;
|
|
19799
|
+
default:
|
|
19800
|
+
pushSharedOption(token, rest, shared);
|
|
19801
|
+
}
|
|
19802
|
+
}
|
|
19803
|
+
if (!id) {
|
|
19804
|
+
throw new Error(`Missing required option --id for store table ${action}`);
|
|
19805
|
+
}
|
|
19806
|
+
return { type: "store" /* Store */, scope: "table", action, name, id, ...shared };
|
|
19807
|
+
}
|
|
19808
|
+
if (action === "create" || action === "update") {
|
|
19809
|
+
let filePath;
|
|
19810
|
+
while (rest.length > 0) {
|
|
19811
|
+
const token = rest.shift();
|
|
19812
|
+
switch (token) {
|
|
19813
|
+
case "--file":
|
|
19814
|
+
filePath = requireValue2(rest, token);
|
|
19815
|
+
break;
|
|
19816
|
+
default:
|
|
19817
|
+
pushSharedOption(token, rest, shared);
|
|
19818
|
+
}
|
|
19819
|
+
}
|
|
19820
|
+
if (!filePath) {
|
|
19821
|
+
throw new Error(`Missing required option --file for store table ${action}`);
|
|
19822
|
+
}
|
|
19823
|
+
return { type: "store" /* Store */, scope: "table", action, name, filePath, ...shared };
|
|
19824
|
+
}
|
|
19825
|
+
throw new Error(`Unknown store table action: ${action}`);
|
|
19826
|
+
}
|
|
19827
|
+
function parseKvArgs(action, rest, shared) {
|
|
19828
|
+
const name = rest.shift();
|
|
19829
|
+
if (!name || name.startsWith("-")) {
|
|
19830
|
+
throw new Error(`Missing kv name. Usage: store kv ${action} <name> ...`);
|
|
19831
|
+
}
|
|
19832
|
+
if (action === "list") {
|
|
19833
|
+
let page = 0;
|
|
19834
|
+
while (rest.length > 0) {
|
|
19835
|
+
const token = rest.shift();
|
|
19836
|
+
switch (token) {
|
|
19837
|
+
case "--page":
|
|
19838
|
+
page = parsePage(requireValue2(rest, token));
|
|
19839
|
+
break;
|
|
19840
|
+
default:
|
|
19841
|
+
pushSharedOption(token, rest, shared);
|
|
19842
|
+
}
|
|
19843
|
+
}
|
|
19844
|
+
return { type: "store" /* Store */, scope: "kv", action, name, page, ...shared };
|
|
19845
|
+
}
|
|
19846
|
+
if (action === "get" || action === "exists" || action === "delete") {
|
|
19847
|
+
let key;
|
|
19848
|
+
while (rest.length > 0) {
|
|
19849
|
+
const token = rest.shift();
|
|
19850
|
+
switch (token) {
|
|
19851
|
+
case "--key":
|
|
19852
|
+
key = requireValue2(rest, token);
|
|
19853
|
+
break;
|
|
19854
|
+
default:
|
|
19855
|
+
pushSharedOption(token, rest, shared);
|
|
19856
|
+
}
|
|
19857
|
+
}
|
|
19858
|
+
if (!key) {
|
|
19859
|
+
throw new Error(`Missing required option --key for store kv ${action}`);
|
|
19860
|
+
}
|
|
19861
|
+
return { type: "store" /* Store */, scope: "kv", action, name, key, ...shared };
|
|
19862
|
+
}
|
|
19863
|
+
if (action === "set") {
|
|
19864
|
+
let key;
|
|
19865
|
+
let value;
|
|
19866
|
+
let filePath;
|
|
19867
|
+
while (rest.length > 0) {
|
|
19868
|
+
const token = rest.shift();
|
|
19869
|
+
switch (token) {
|
|
19870
|
+
case "--key":
|
|
19871
|
+
key = requireValue2(rest, token);
|
|
19872
|
+
break;
|
|
19873
|
+
case "--value":
|
|
19874
|
+
value = requireValue2(rest, token);
|
|
19875
|
+
break;
|
|
19876
|
+
case "--file":
|
|
19877
|
+
filePath = requireValue2(rest, token);
|
|
19878
|
+
break;
|
|
19879
|
+
default:
|
|
19880
|
+
pushSharedOption(token, rest, shared);
|
|
19881
|
+
}
|
|
19882
|
+
}
|
|
19883
|
+
if (!key) {
|
|
19884
|
+
throw new Error("Missing required option --key for store kv set");
|
|
19885
|
+
}
|
|
19886
|
+
if (!value && !filePath || value && filePath) {
|
|
19887
|
+
throw new Error("Provide exactly one of --value or --file for store kv set");
|
|
19888
|
+
}
|
|
19889
|
+
return { type: "store" /* Store */, scope: "kv", action, name, key, value, filePath, ...shared };
|
|
19890
|
+
}
|
|
19891
|
+
throw new Error(`Unknown store kv action: ${action}`);
|
|
19892
|
+
}
|
|
19893
|
+
function takeSharedOptions(rest, shared) {
|
|
19894
|
+
while (rest.length > 0) {
|
|
19895
|
+
const token = rest.shift();
|
|
19896
|
+
pushSharedOption(token, rest, shared);
|
|
19897
|
+
}
|
|
19898
|
+
}
|
|
19899
|
+
function pushSharedOption(token, rest, shared) {
|
|
19900
|
+
switch (token) {
|
|
19901
|
+
case "--chain":
|
|
19902
|
+
shared.chain = requireValue2(rest, token);
|
|
19903
|
+
break;
|
|
19904
|
+
case "--ns":
|
|
19905
|
+
case "--namespace":
|
|
19906
|
+
shared.namespace = requireValue2(rest, token);
|
|
19907
|
+
break;
|
|
19908
|
+
case "--base-url":
|
|
19909
|
+
shared.baseUrl = requireValue2(rest, token);
|
|
19910
|
+
break;
|
|
19911
|
+
case "--indexer-base-url":
|
|
19912
|
+
shared.indexerBaseUrl = requireValue2(rest, token);
|
|
19913
|
+
break;
|
|
19914
|
+
case "--json":
|
|
19915
|
+
shared.json = true;
|
|
19916
|
+
break;
|
|
19917
|
+
default:
|
|
19918
|
+
throw new Error(`Unknown store option: ${token}`);
|
|
19919
|
+
}
|
|
19920
|
+
}
|
|
19921
|
+
function requireValue2(tokens, optionName) {
|
|
19922
|
+
const value = tokens.shift();
|
|
19923
|
+
if (!value || value.startsWith("-")) {
|
|
19924
|
+
throw new Error(`Missing value for ${optionName}`);
|
|
19925
|
+
}
|
|
19926
|
+
return value;
|
|
19927
|
+
}
|
|
19928
|
+
function parsePage(value) {
|
|
19929
|
+
const page = Number.parseInt(value, 10);
|
|
19930
|
+
if (!Number.isInteger(page) || page < 0) {
|
|
19931
|
+
throw new Error(`Invalid --page value: ${value}`);
|
|
19932
|
+
}
|
|
19933
|
+
return page;
|
|
19934
|
+
}
|
|
19935
|
+
|
|
19234
19936
|
// src/appCommandParser.ts
|
|
19235
19937
|
function parseAppArgs(tokens) {
|
|
19236
19938
|
const rest = [...tokens];
|
|
@@ -19240,12 +19942,12 @@ function parseAppArgs(tokens) {
|
|
|
19240
19942
|
}
|
|
19241
19943
|
let baseUrl;
|
|
19242
19944
|
let json = false;
|
|
19243
|
-
const
|
|
19945
|
+
const takeSharedOptions2 = () => {
|
|
19244
19946
|
while (rest.length > 0) {
|
|
19245
19947
|
const token = rest[0];
|
|
19246
19948
|
if (token === "--base-url") {
|
|
19247
19949
|
rest.shift();
|
|
19248
|
-
baseUrl =
|
|
19950
|
+
baseUrl = requireValue3(rest, token);
|
|
19249
19951
|
continue;
|
|
19250
19952
|
}
|
|
19251
19953
|
if (token === "--json") {
|
|
@@ -19257,7 +19959,7 @@ function parseAppArgs(tokens) {
|
|
|
19257
19959
|
}
|
|
19258
19960
|
};
|
|
19259
19961
|
if (action === "list") {
|
|
19260
|
-
|
|
19962
|
+
takeSharedOptions2();
|
|
19261
19963
|
if (rest.length > 0) {
|
|
19262
19964
|
throw new Error(`Unknown app list option: ${rest[0]}`);
|
|
19263
19965
|
}
|
|
@@ -19270,7 +19972,7 @@ function parseAppArgs(tokens) {
|
|
|
19270
19972
|
`Usage: app ${action} <id> [--base-url <url>] [--json]`
|
|
19271
19973
|
);
|
|
19272
19974
|
}
|
|
19273
|
-
|
|
19975
|
+
takeSharedOptions2();
|
|
19274
19976
|
if (rest.length > 0) {
|
|
19275
19977
|
throw new Error(`Unknown app ${action} option: ${rest[0]}`);
|
|
19276
19978
|
}
|
|
@@ -19282,10 +19984,10 @@ function parseAppArgs(tokens) {
|
|
|
19282
19984
|
const token = rest.shift();
|
|
19283
19985
|
switch (token) {
|
|
19284
19986
|
case "--file":
|
|
19285
|
-
filePath =
|
|
19987
|
+
filePath = requireValue3(rest, token);
|
|
19286
19988
|
break;
|
|
19287
19989
|
case "--base-url":
|
|
19288
|
-
baseUrl =
|
|
19990
|
+
baseUrl = requireValue3(rest, token);
|
|
19289
19991
|
break;
|
|
19290
19992
|
case "--json":
|
|
19291
19993
|
json = true;
|
|
@@ -19311,10 +20013,10 @@ function parseAppArgs(tokens) {
|
|
|
19311
20013
|
const token = rest.shift();
|
|
19312
20014
|
switch (token) {
|
|
19313
20015
|
case "--file":
|
|
19314
|
-
filePath =
|
|
20016
|
+
filePath = requireValue3(rest, token);
|
|
19315
20017
|
break;
|
|
19316
20018
|
case "--base-url":
|
|
19317
|
-
baseUrl =
|
|
20019
|
+
baseUrl = requireValue3(rest, token);
|
|
19318
20020
|
break;
|
|
19319
20021
|
case "--json":
|
|
19320
20022
|
json = true;
|
|
@@ -19330,7 +20032,7 @@ function parseAppArgs(tokens) {
|
|
|
19330
20032
|
}
|
|
19331
20033
|
throw new Error(`Unknown app action: ${action}`);
|
|
19332
20034
|
}
|
|
19333
|
-
function
|
|
20035
|
+
function requireValue3(tokens, optionName) {
|
|
19334
20036
|
const value = tokens.shift();
|
|
19335
20037
|
if (!value || value.startsWith("-")) {
|
|
19336
20038
|
throw new Error(`Missing value for ${optionName}`);
|
|
@@ -19340,7 +20042,7 @@ function requireValue2(tokens, optionName) {
|
|
|
19340
20042
|
|
|
19341
20043
|
// src/index.ts
|
|
19342
20044
|
var pkg = JSON.parse(
|
|
19343
|
-
(0,
|
|
20045
|
+
(0, import_node_fs15.readFileSync)(import_node_path20.default.resolve(__dirname, "..", "package.json"), "utf8")
|
|
19344
20046
|
);
|
|
19345
20047
|
var HELP_TEXT = [
|
|
19346
20048
|
import_chalk3.default.bold(`pmate v${pkg.version}`),
|
|
@@ -19424,6 +20126,11 @@ var HELP_TEXT = [
|
|
|
19424
20126
|
` ${import_chalk3.default.gray(" update [<namespace>] <name> --file <path> [--base-url <url>] [--json]")}`,
|
|
19425
20127
|
` ${import_chalk3.default.gray(" delete [<namespace>] <name> [--base-url <url>] [--json]")}`,
|
|
19426
20128
|
` ${import_chalk3.default.gray(" default namespace: pmate; default base URL: https://agent-api.pmate.chat")}`,
|
|
20129
|
+
` ${import_chalk3.default.cyan("store")} Manage @pmate/store namespaces, tables, and kv stores`,
|
|
20130
|
+
` ${import_chalk3.default.gray(" namespace list [--chain <chain>] [--indexer-base-url <url>] [--json]")}`,
|
|
20131
|
+
` ${import_chalk3.default.gray(" table list|get|exists|create|update|delete <name> [options]")}`,
|
|
20132
|
+
` ${import_chalk3.default.gray(" kv list|get|exists|set|delete <name> [options]")}`,
|
|
20133
|
+
` ${import_chalk3.default.gray(" defaults: chain=pmate namespace=pmate env base URLs from BLOCKCHAIN_BASE_URL / INDEXER_BASE_URL")}`,
|
|
19427
20134
|
` ${import_chalk3.default.cyan("app")} Manage app registry entries via apps-api`,
|
|
19428
20135
|
` ${import_chalk3.default.gray(" list [--base-url <url>] [--json]")}`,
|
|
19429
20136
|
` ${import_chalk3.default.gray(" get <id> [--base-url <url>] [--json]")}`,
|
|
@@ -19491,7 +20198,7 @@ function parseCommandArgs(args) {
|
|
|
19491
20198
|
const token = rest.shift();
|
|
19492
20199
|
switch (token) {
|
|
19493
20200
|
case "--app":
|
|
19494
|
-
app =
|
|
20201
|
+
app = requireValue4(rest, token);
|
|
19495
20202
|
break;
|
|
19496
20203
|
default:
|
|
19497
20204
|
throw new Error(`Unknown login option: ${token}`);
|
|
@@ -19556,6 +20263,9 @@ function parseCommandArgs(args) {
|
|
|
19556
20263
|
if (args.rest[0] === "agent") {
|
|
19557
20264
|
return parseAgentArgs(args.rest.slice(1));
|
|
19558
20265
|
}
|
|
20266
|
+
if (args.rest[0] === "store") {
|
|
20267
|
+
return parseStoreArgs(args.rest.slice(1));
|
|
20268
|
+
}
|
|
19559
20269
|
if (args.rest[0] === "app") {
|
|
19560
20270
|
return parseAppArgs(args.rest.slice(1));
|
|
19561
20271
|
}
|
|
@@ -19576,7 +20286,7 @@ function parseVercelArgs(tokens) {
|
|
|
19576
20286
|
const token = rest.shift();
|
|
19577
20287
|
switch (token) {
|
|
19578
20288
|
case "--scope":
|
|
19579
|
-
scope =
|
|
20289
|
+
scope = requireValue4(rest, token);
|
|
19580
20290
|
break;
|
|
19581
20291
|
default:
|
|
19582
20292
|
throw new Error(`Unknown vercel option: ${token}`);
|
|
@@ -19596,10 +20306,10 @@ function parseVercelArgs(tokens) {
|
|
|
19596
20306
|
const token = rest.shift();
|
|
19597
20307
|
switch (token) {
|
|
19598
20308
|
case "--scope":
|
|
19599
|
-
scope =
|
|
20309
|
+
scope = requireValue4(rest, token);
|
|
19600
20310
|
break;
|
|
19601
20311
|
case "--project":
|
|
19602
|
-
project =
|
|
20312
|
+
project = requireValue4(rest, token);
|
|
19603
20313
|
break;
|
|
19604
20314
|
case "--last-week":
|
|
19605
20315
|
lastWeek = true;
|
|
@@ -19630,16 +20340,16 @@ function parseAddDnsArgs(tokens) {
|
|
|
19630
20340
|
const token = rest.shift();
|
|
19631
20341
|
switch (token) {
|
|
19632
20342
|
case "--type":
|
|
19633
|
-
options.dnsType =
|
|
20343
|
+
options.dnsType = requireValue4(rest, token);
|
|
19634
20344
|
break;
|
|
19635
20345
|
case "--value":
|
|
19636
|
-
options.dnsValue =
|
|
20346
|
+
options.dnsValue = requireValue4(rest, token);
|
|
19637
20347
|
break;
|
|
19638
20348
|
case "--rr":
|
|
19639
|
-
options.dnsRr =
|
|
20349
|
+
options.dnsRr = requireValue4(rest, token);
|
|
19640
20350
|
break;
|
|
19641
20351
|
case "--ttl": {
|
|
19642
|
-
const ttlValue =
|
|
20352
|
+
const ttlValue = requireValue4(rest, token);
|
|
19643
20353
|
const ttl = Number.parseInt(ttlValue, 10);
|
|
19644
20354
|
if (!Number.isFinite(ttl) || ttl <= 0) {
|
|
19645
20355
|
throw new Error(`Invalid --ttl value: ${ttlValue}`);
|
|
@@ -19648,7 +20358,7 @@ function parseAddDnsArgs(tokens) {
|
|
|
19648
20358
|
break;
|
|
19649
20359
|
}
|
|
19650
20360
|
case "--domain":
|
|
19651
|
-
options.dnsDomain =
|
|
20361
|
+
options.dnsDomain = requireValue4(rest, token);
|
|
19652
20362
|
break;
|
|
19653
20363
|
default:
|
|
19654
20364
|
throw new Error(`Unknown add-dns option: ${token}`);
|
|
@@ -19679,7 +20389,7 @@ function parseBucketArgs(tokens) {
|
|
|
19679
20389
|
options.bucketCreate = true;
|
|
19680
20390
|
break;
|
|
19681
20391
|
case "--name":
|
|
19682
|
-
options.bucketName =
|
|
20392
|
+
options.bucketName = requireValue4(rest, token);
|
|
19683
20393
|
break;
|
|
19684
20394
|
default:
|
|
19685
20395
|
throw new Error(`Unknown bucket option: ${token}`);
|
|
@@ -19715,7 +20425,7 @@ function parseDeployArgs(tokens) {
|
|
|
19715
20425
|
options.deployAction = "logs";
|
|
19716
20426
|
break;
|
|
19717
20427
|
case "--cwd":
|
|
19718
|
-
options.deployCwd =
|
|
20428
|
+
options.deployCwd = requireValue4(rest, token);
|
|
19719
20429
|
break;
|
|
19720
20430
|
default:
|
|
19721
20431
|
throw new Error(`Unknown deploy option: ${token}`);
|
|
@@ -19740,13 +20450,13 @@ function parseLogArgs(tokens) {
|
|
|
19740
20450
|
const token = rest.shift();
|
|
19741
20451
|
switch (token) {
|
|
19742
20452
|
case "--cwd":
|
|
19743
|
-
options.logCwd =
|
|
20453
|
+
options.logCwd = requireValue4(rest, token);
|
|
19744
20454
|
break;
|
|
19745
20455
|
case "--ns":
|
|
19746
|
-
options.logNamespace =
|
|
20456
|
+
options.logNamespace = requireValue4(rest, token);
|
|
19747
20457
|
break;
|
|
19748
20458
|
case "--page": {
|
|
19749
|
-
const value =
|
|
20459
|
+
const value = requireValue4(rest, token);
|
|
19750
20460
|
const page = Number.parseInt(value, 10);
|
|
19751
20461
|
if (!Number.isFinite(page) || page < 0) {
|
|
19752
20462
|
throw new Error(`Invalid log page: ${value}`);
|
|
@@ -19758,7 +20468,7 @@ function parseLogArgs(tokens) {
|
|
|
19758
20468
|
options.logHistory = true;
|
|
19759
20469
|
break;
|
|
19760
20470
|
case "--search":
|
|
19761
|
-
options.logSearch =
|
|
20471
|
+
options.logSearch = requireValue4(rest, token);
|
|
19762
20472
|
break;
|
|
19763
20473
|
default:
|
|
19764
20474
|
throw new Error(`Unknown log option: ${token}`);
|
|
@@ -19781,7 +20491,7 @@ function parseInitArgs(tokens) {
|
|
|
19781
20491
|
const token = rest.shift();
|
|
19782
20492
|
switch (token) {
|
|
19783
20493
|
case "--cwd":
|
|
19784
|
-
options.initCwd =
|
|
20494
|
+
options.initCwd = requireValue4(rest, token);
|
|
19785
20495
|
break;
|
|
19786
20496
|
default:
|
|
19787
20497
|
throw new Error(`Unknown init option: ${token}`);
|
|
@@ -19804,7 +20514,7 @@ function parseDevArgs(tokens) {
|
|
|
19804
20514
|
const token = rest.shift();
|
|
19805
20515
|
switch (token) {
|
|
19806
20516
|
case "--cwd":
|
|
19807
|
-
options.devCwd =
|
|
20517
|
+
options.devCwd = requireValue4(rest, token);
|
|
19808
20518
|
break;
|
|
19809
20519
|
default:
|
|
19810
20520
|
throw new Error(`Unknown dev option: ${token}`);
|
|
@@ -19834,13 +20544,13 @@ function parseOssArgs(tokens) {
|
|
|
19834
20544
|
const token = rest.shift();
|
|
19835
20545
|
switch (token) {
|
|
19836
20546
|
case "--bucket":
|
|
19837
|
-
bucket =
|
|
20547
|
+
bucket = requireValue4(rest, token);
|
|
19838
20548
|
break;
|
|
19839
20549
|
case "--file":
|
|
19840
|
-
filePath =
|
|
20550
|
+
filePath = requireValue4(rest, token);
|
|
19841
20551
|
break;
|
|
19842
20552
|
case "--key":
|
|
19843
|
-
objectKey =
|
|
20553
|
+
objectKey = requireValue4(rest, token);
|
|
19844
20554
|
break;
|
|
19845
20555
|
default:
|
|
19846
20556
|
throw new Error(`Unknown oss option: ${token}`);
|
|
@@ -19873,7 +20583,7 @@ function parseEnvArgs(tokens) {
|
|
|
19873
20583
|
throw new Error("Only one env action is allowed.");
|
|
19874
20584
|
}
|
|
19875
20585
|
action = "set";
|
|
19876
|
-
key =
|
|
20586
|
+
key = requireValue4(rest, token);
|
|
19877
20587
|
break;
|
|
19878
20588
|
case "--list":
|
|
19879
20589
|
if (action) {
|
|
@@ -19886,17 +20596,17 @@ function parseEnvArgs(tokens) {
|
|
|
19886
20596
|
throw new Error("Only one env action is allowed.");
|
|
19887
20597
|
}
|
|
19888
20598
|
action = "delete";
|
|
19889
|
-
key =
|
|
20599
|
+
key = requireValue4(rest, token);
|
|
19890
20600
|
break;
|
|
19891
20601
|
case "--value":
|
|
19892
|
-
value =
|
|
20602
|
+
value = requireValue4(rest, token);
|
|
19893
20603
|
break;
|
|
19894
20604
|
case "--verbose":
|
|
19895
20605
|
case "-v":
|
|
19896
20606
|
verbose = true;
|
|
19897
20607
|
break;
|
|
19898
20608
|
case "--cwd":
|
|
19899
|
-
cwd =
|
|
20609
|
+
cwd = requireValue4(rest, token);
|
|
19900
20610
|
break;
|
|
19901
20611
|
default:
|
|
19902
20612
|
throw new Error(`Unknown env option: ${token}`);
|
|
@@ -19954,7 +20664,7 @@ function parseCommitArgs(tokens) {
|
|
|
19954
20664
|
push = true;
|
|
19955
20665
|
break;
|
|
19956
20666
|
case "--cwd":
|
|
19957
|
-
cwd =
|
|
20667
|
+
cwd = requireValue4(rest, token);
|
|
19958
20668
|
break;
|
|
19959
20669
|
default:
|
|
19960
20670
|
throw new Error(`Unknown commit option: ${token}`);
|
|
@@ -19970,10 +20680,10 @@ function parseSummaryArgs(tokens) {
|
|
|
19970
20680
|
const token = rest.shift();
|
|
19971
20681
|
switch (token) {
|
|
19972
20682
|
case "--pr":
|
|
19973
|
-
prRef =
|
|
20683
|
+
prRef = requireValue4(rest, token);
|
|
19974
20684
|
break;
|
|
19975
20685
|
case "--cwd":
|
|
19976
|
-
cwd =
|
|
20686
|
+
cwd = requireValue4(rest, token);
|
|
19977
20687
|
break;
|
|
19978
20688
|
default:
|
|
19979
20689
|
throw new Error(`Unknown summary option: ${token}`);
|
|
@@ -20042,10 +20752,10 @@ function parseLinearPrArgs(tokens) {
|
|
|
20042
20752
|
const token = rest.shift();
|
|
20043
20753
|
switch (token) {
|
|
20044
20754
|
case "--account":
|
|
20045
|
-
account =
|
|
20755
|
+
account = requireValue4(rest, token);
|
|
20046
20756
|
break;
|
|
20047
20757
|
case "--cwd":
|
|
20048
|
-
cwd =
|
|
20758
|
+
cwd = requireValue4(rest, token);
|
|
20049
20759
|
break;
|
|
20050
20760
|
default:
|
|
20051
20761
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20074,35 +20784,35 @@ function parseLinearCreateArgs(tokens) {
|
|
|
20074
20784
|
const token = rest.shift();
|
|
20075
20785
|
switch (token) {
|
|
20076
20786
|
case "--account":
|
|
20077
|
-
account =
|
|
20787
|
+
account = requireValue4(rest, token);
|
|
20078
20788
|
break;
|
|
20079
20789
|
case "--repl":
|
|
20080
20790
|
useRepl = true;
|
|
20081
20791
|
break;
|
|
20082
20792
|
case "--title":
|
|
20083
|
-
title =
|
|
20793
|
+
title = requireValue4(rest, token);
|
|
20084
20794
|
break;
|
|
20085
20795
|
case "--desc":
|
|
20086
20796
|
case "--description":
|
|
20087
|
-
description = decodeEscapedNewlines(
|
|
20797
|
+
description = decodeEscapedNewlines(requireValue4(rest, token));
|
|
20088
20798
|
break;
|
|
20089
20799
|
case "--team-id":
|
|
20090
|
-
teamId =
|
|
20800
|
+
teamId = requireValue4(rest, token);
|
|
20091
20801
|
break;
|
|
20092
20802
|
case "--team-key":
|
|
20093
|
-
teamKey =
|
|
20803
|
+
teamKey = requireValue4(rest, token);
|
|
20094
20804
|
break;
|
|
20095
20805
|
case "--priority":
|
|
20096
|
-
priority = parseLinearPriority(
|
|
20806
|
+
priority = parseLinearPriority(requireValue4(rest, token));
|
|
20097
20807
|
break;
|
|
20098
20808
|
case "--parent-id":
|
|
20099
|
-
parentId =
|
|
20809
|
+
parentId = requireValue4(rest, token);
|
|
20100
20810
|
break;
|
|
20101
20811
|
case "--state-id":
|
|
20102
|
-
stateId =
|
|
20812
|
+
stateId = requireValue4(rest, token);
|
|
20103
20813
|
break;
|
|
20104
20814
|
case "--cwd":
|
|
20105
|
-
cwd =
|
|
20815
|
+
cwd = requireValue4(rest, token);
|
|
20106
20816
|
break;
|
|
20107
20817
|
default:
|
|
20108
20818
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20137,10 +20847,10 @@ function parseLinearWhoamiArgs(tokens) {
|
|
|
20137
20847
|
const token = rest.shift();
|
|
20138
20848
|
switch (token) {
|
|
20139
20849
|
case "--account":
|
|
20140
|
-
account =
|
|
20850
|
+
account = requireValue4(rest, token);
|
|
20141
20851
|
break;
|
|
20142
20852
|
case "--cwd":
|
|
20143
|
-
cwd =
|
|
20853
|
+
cwd = requireValue4(rest, token);
|
|
20144
20854
|
break;
|
|
20145
20855
|
default:
|
|
20146
20856
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20165,10 +20875,10 @@ function parseLinearViewArgs(tokens) {
|
|
|
20165
20875
|
const token = rest.shift();
|
|
20166
20876
|
switch (token) {
|
|
20167
20877
|
case "--account":
|
|
20168
|
-
account =
|
|
20878
|
+
account = requireValue4(rest, token);
|
|
20169
20879
|
break;
|
|
20170
20880
|
case "--cwd":
|
|
20171
|
-
cwd =
|
|
20881
|
+
cwd = requireValue4(rest, token);
|
|
20172
20882
|
break;
|
|
20173
20883
|
default:
|
|
20174
20884
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20203,32 +20913,32 @@ function parseLinearUpdateArgs(tokens) {
|
|
|
20203
20913
|
const token = rest.shift();
|
|
20204
20914
|
switch (token) {
|
|
20205
20915
|
case "--account":
|
|
20206
|
-
account =
|
|
20916
|
+
account = requireValue4(rest, token);
|
|
20207
20917
|
break;
|
|
20208
20918
|
case "--title":
|
|
20209
|
-
title =
|
|
20919
|
+
title = requireValue4(rest, token);
|
|
20210
20920
|
break;
|
|
20211
20921
|
case "--desc":
|
|
20212
20922
|
case "--description":
|
|
20213
|
-
description = decodeEscapedNewlines(
|
|
20923
|
+
description = decodeEscapedNewlines(requireValue4(rest, token));
|
|
20214
20924
|
break;
|
|
20215
20925
|
case "--team-id":
|
|
20216
|
-
teamId =
|
|
20926
|
+
teamId = requireValue4(rest, token);
|
|
20217
20927
|
break;
|
|
20218
20928
|
case "--team-key":
|
|
20219
|
-
teamKey =
|
|
20929
|
+
teamKey = requireValue4(rest, token);
|
|
20220
20930
|
break;
|
|
20221
20931
|
case "--priority":
|
|
20222
|
-
priority = parseLinearPriority(
|
|
20932
|
+
priority = parseLinearPriority(requireValue4(rest, token));
|
|
20223
20933
|
break;
|
|
20224
20934
|
case "--parent-id":
|
|
20225
|
-
parentId =
|
|
20935
|
+
parentId = requireValue4(rest, token);
|
|
20226
20936
|
break;
|
|
20227
20937
|
case "--state-id":
|
|
20228
|
-
stateId =
|
|
20938
|
+
stateId = requireValue4(rest, token);
|
|
20229
20939
|
break;
|
|
20230
20940
|
case "--cwd":
|
|
20231
|
-
cwd =
|
|
20941
|
+
cwd = requireValue4(rest, token);
|
|
20232
20942
|
break;
|
|
20233
20943
|
default:
|
|
20234
20944
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20266,10 +20976,10 @@ function parseLinearSubIssuesArgs(tokens) {
|
|
|
20266
20976
|
const token = rest.shift();
|
|
20267
20977
|
switch (token) {
|
|
20268
20978
|
case "--account":
|
|
20269
|
-
account =
|
|
20979
|
+
account = requireValue4(rest, token);
|
|
20270
20980
|
break;
|
|
20271
20981
|
case "--cwd":
|
|
20272
|
-
cwd =
|
|
20982
|
+
cwd = requireValue4(rest, token);
|
|
20273
20983
|
break;
|
|
20274
20984
|
default:
|
|
20275
20985
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20296,15 +21006,15 @@ function parseLinearCommentArgs(tokens) {
|
|
|
20296
21006
|
const token = rest.shift();
|
|
20297
21007
|
switch (token) {
|
|
20298
21008
|
case "--account":
|
|
20299
|
-
account =
|
|
21009
|
+
account = requireValue4(rest, token);
|
|
20300
21010
|
break;
|
|
20301
21011
|
case "--body":
|
|
20302
21012
|
case "--desc":
|
|
20303
21013
|
case "--description":
|
|
20304
|
-
body = decodeEscapedNewlines(
|
|
21014
|
+
body = decodeEscapedNewlines(requireValue4(rest, token));
|
|
20305
21015
|
break;
|
|
20306
21016
|
case "--cwd":
|
|
20307
|
-
cwd =
|
|
21017
|
+
cwd = requireValue4(rest, token);
|
|
20308
21018
|
break;
|
|
20309
21019
|
default:
|
|
20310
21020
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20334,10 +21044,10 @@ function parseLinearCommentsArgs(tokens) {
|
|
|
20334
21044
|
const token = rest.shift();
|
|
20335
21045
|
switch (token) {
|
|
20336
21046
|
case "--account":
|
|
20337
|
-
account =
|
|
21047
|
+
account = requireValue4(rest, token);
|
|
20338
21048
|
break;
|
|
20339
21049
|
case "--cwd":
|
|
20340
|
-
cwd =
|
|
21050
|
+
cwd = requireValue4(rest, token);
|
|
20341
21051
|
break;
|
|
20342
21052
|
default:
|
|
20343
21053
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20361,16 +21071,16 @@ function parseLinearCycleArgs(tokens) {
|
|
|
20361
21071
|
const token = rest.shift();
|
|
20362
21072
|
switch (token) {
|
|
20363
21073
|
case "--account":
|
|
20364
|
-
account =
|
|
21074
|
+
account = requireValue4(rest, token);
|
|
20365
21075
|
break;
|
|
20366
21076
|
case "--team-id":
|
|
20367
|
-
teamId =
|
|
21077
|
+
teamId = requireValue4(rest, token);
|
|
20368
21078
|
break;
|
|
20369
21079
|
case "--team-key":
|
|
20370
|
-
teamKey =
|
|
21080
|
+
teamKey = requireValue4(rest, token);
|
|
20371
21081
|
break;
|
|
20372
21082
|
case "--cwd":
|
|
20373
|
-
cwd =
|
|
21083
|
+
cwd = requireValue4(rest, token);
|
|
20374
21084
|
break;
|
|
20375
21085
|
default:
|
|
20376
21086
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20393,10 +21103,10 @@ function parseLinearTeamsArgs(tokens) {
|
|
|
20393
21103
|
const token = rest.shift();
|
|
20394
21104
|
switch (token) {
|
|
20395
21105
|
case "--account":
|
|
20396
|
-
account =
|
|
21106
|
+
account = requireValue4(rest, token);
|
|
20397
21107
|
break;
|
|
20398
21108
|
case "--cwd":
|
|
20399
|
-
cwd =
|
|
21109
|
+
cwd = requireValue4(rest, token);
|
|
20400
21110
|
break;
|
|
20401
21111
|
default:
|
|
20402
21112
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20423,16 +21133,16 @@ function parseLinearUserIssuesArgs(tokens) {
|
|
|
20423
21133
|
const token = rest.shift();
|
|
20424
21134
|
switch (token) {
|
|
20425
21135
|
case "--account":
|
|
20426
|
-
account =
|
|
21136
|
+
account = requireValue4(rest, token);
|
|
20427
21137
|
break;
|
|
20428
21138
|
case "--cycle":
|
|
20429
|
-
cycle = parseLinearCycle(
|
|
21139
|
+
cycle = parseLinearCycle(requireValue4(rest, token));
|
|
20430
21140
|
break;
|
|
20431
21141
|
case "--status":
|
|
20432
|
-
status = parseLinearStatus(
|
|
21142
|
+
status = parseLinearStatus(requireValue4(rest, token));
|
|
20433
21143
|
break;
|
|
20434
21144
|
case "--cwd":
|
|
20435
|
-
cwd =
|
|
21145
|
+
cwd = requireValue4(rest, token);
|
|
20436
21146
|
break;
|
|
20437
21147
|
default:
|
|
20438
21148
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20466,28 +21176,28 @@ function parseLinearIssuesArgs(tokens) {
|
|
|
20466
21176
|
const token = rest.shift();
|
|
20467
21177
|
switch (token) {
|
|
20468
21178
|
case "--account":
|
|
20469
|
-
account =
|
|
21179
|
+
account = requireValue4(rest, token);
|
|
20470
21180
|
break;
|
|
20471
21181
|
case "--team-id":
|
|
20472
|
-
teamId =
|
|
21182
|
+
teamId = requireValue4(rest, token);
|
|
20473
21183
|
break;
|
|
20474
21184
|
case "--team-key":
|
|
20475
|
-
teamKey =
|
|
21185
|
+
teamKey = requireValue4(rest, token);
|
|
20476
21186
|
break;
|
|
20477
21187
|
case "--user":
|
|
20478
|
-
user =
|
|
21188
|
+
user = requireValue4(rest, token);
|
|
20479
21189
|
break;
|
|
20480
21190
|
case "--cycle":
|
|
20481
|
-
cycle = parseLinearCycle(
|
|
21191
|
+
cycle = parseLinearCycle(requireValue4(rest, token));
|
|
20482
21192
|
break;
|
|
20483
21193
|
case "--status":
|
|
20484
|
-
status = parseLinearStatus(
|
|
21194
|
+
status = parseLinearStatus(requireValue4(rest, token));
|
|
20485
21195
|
break;
|
|
20486
21196
|
case "--query":
|
|
20487
|
-
query =
|
|
21197
|
+
query = requireValue4(rest, token).trim();
|
|
20488
21198
|
break;
|
|
20489
21199
|
case "--limit": {
|
|
20490
|
-
const value = Number.parseInt(
|
|
21200
|
+
const value = Number.parseInt(requireValue4(rest, token), 10);
|
|
20491
21201
|
if (!Number.isInteger(value) || value < 1 || value > 250) {
|
|
20492
21202
|
throw new Error("Invalid --limit. Expected an integer between 1 and 250.");
|
|
20493
21203
|
}
|
|
@@ -20495,7 +21205,7 @@ function parseLinearIssuesArgs(tokens) {
|
|
|
20495
21205
|
break;
|
|
20496
21206
|
}
|
|
20497
21207
|
case "--cwd":
|
|
20498
|
-
cwd =
|
|
21208
|
+
cwd = requireValue4(rest, token);
|
|
20499
21209
|
break;
|
|
20500
21210
|
default:
|
|
20501
21211
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20536,10 +21246,10 @@ function parseLinearLegacyArgs(tokens) {
|
|
|
20536
21246
|
useScreenshot = true;
|
|
20537
21247
|
break;
|
|
20538
21248
|
case "--account":
|
|
20539
|
-
account =
|
|
21249
|
+
account = requireValue4(rest, token);
|
|
20540
21250
|
break;
|
|
20541
21251
|
case "--cwd":
|
|
20542
|
-
cwd =
|
|
21252
|
+
cwd = requireValue4(rest, token);
|
|
20543
21253
|
break;
|
|
20544
21254
|
default:
|
|
20545
21255
|
throw new Error(`Unknown linear option: ${token}`);
|
|
@@ -20633,19 +21343,19 @@ function parseNotionArgs(tokens) {
|
|
|
20633
21343
|
const token = rest.shift();
|
|
20634
21344
|
switch (token) {
|
|
20635
21345
|
case "--parent":
|
|
20636
|
-
parentPageId =
|
|
21346
|
+
parentPageId = requireValue4(rest, token);
|
|
20637
21347
|
break;
|
|
20638
21348
|
case "--title":
|
|
20639
|
-
title =
|
|
21349
|
+
title = requireValue4(rest, token);
|
|
20640
21350
|
break;
|
|
20641
21351
|
case "--private":
|
|
20642
21352
|
isPrivate = true;
|
|
20643
21353
|
break;
|
|
20644
21354
|
case "--content":
|
|
20645
|
-
content2 =
|
|
21355
|
+
content2 = requireValue4(rest, token);
|
|
20646
21356
|
break;
|
|
20647
21357
|
case "--file":
|
|
20648
|
-
filePath2 =
|
|
21358
|
+
filePath2 = requireValue4(rest, token);
|
|
20649
21359
|
break;
|
|
20650
21360
|
default:
|
|
20651
21361
|
throw new Error(`Unknown notion option: ${token}`);
|
|
@@ -20689,10 +21399,10 @@ function parseNotionArgs(tokens) {
|
|
|
20689
21399
|
const token = rest.shift();
|
|
20690
21400
|
switch (token) {
|
|
20691
21401
|
case "--content":
|
|
20692
|
-
content =
|
|
21402
|
+
content = requireValue4(rest, token);
|
|
20693
21403
|
break;
|
|
20694
21404
|
case "--file":
|
|
20695
|
-
filePath =
|
|
21405
|
+
filePath = requireValue4(rest, token);
|
|
20696
21406
|
break;
|
|
20697
21407
|
case "--append":
|
|
20698
21408
|
append = true;
|
|
@@ -20737,11 +21447,11 @@ function parseRandomArgs(tokens) {
|
|
|
20737
21447
|
mode = "easy";
|
|
20738
21448
|
break;
|
|
20739
21449
|
case "--length":
|
|
20740
|
-
length = parsePositiveInt(
|
|
21450
|
+
length = parsePositiveInt(requireValue4(rest, token), token);
|
|
20741
21451
|
seenLength = true;
|
|
20742
21452
|
break;
|
|
20743
21453
|
case "--charset": {
|
|
20744
|
-
const value =
|
|
21454
|
+
const value = requireValue4(rest, token);
|
|
20745
21455
|
if (!["base64url", "hex", "alnum", "ascii"].includes(value)) {
|
|
20746
21456
|
throw new Error(
|
|
20747
21457
|
`Invalid --charset value: ${value}. Use base64url|hex|alnum|ascii.`
|
|
@@ -20752,18 +21462,18 @@ function parseRandomArgs(tokens) {
|
|
|
20752
21462
|
break;
|
|
20753
21463
|
}
|
|
20754
21464
|
case "--count":
|
|
20755
|
-
count = parsePositiveInt(
|
|
21465
|
+
count = parsePositiveInt(requireValue4(rest, token), token);
|
|
20756
21466
|
break;
|
|
20757
21467
|
case "--words":
|
|
20758
|
-
words = parsePositiveInt(
|
|
21468
|
+
words = parsePositiveInt(requireValue4(rest, token), token);
|
|
20759
21469
|
seenWords = true;
|
|
20760
21470
|
break;
|
|
20761
21471
|
case "--digits":
|
|
20762
|
-
digits = parseNonNegativeInt(
|
|
21472
|
+
digits = parseNonNegativeInt(requireValue4(rest, token), token);
|
|
20763
21473
|
seenDigits = true;
|
|
20764
21474
|
break;
|
|
20765
21475
|
case "--separator":
|
|
20766
|
-
separator =
|
|
21476
|
+
separator = requireValue4(rest, token);
|
|
20767
21477
|
seenSeparator = true;
|
|
20768
21478
|
break;
|
|
20769
21479
|
default:
|
|
@@ -20806,7 +21516,7 @@ function parseCollectArgs(tokens) {
|
|
|
20806
21516
|
const token = rest.shift();
|
|
20807
21517
|
switch (token) {
|
|
20808
21518
|
case "--endpoint":
|
|
20809
|
-
options.endpoint =
|
|
21519
|
+
options.endpoint = requireValue4(rest, token);
|
|
20810
21520
|
break;
|
|
20811
21521
|
case "--json":
|
|
20812
21522
|
options.json = true;
|
|
@@ -20816,7 +21526,7 @@ function parseCollectArgs(tokens) {
|
|
|
20816
21526
|
break;
|
|
20817
21527
|
case "--thread":
|
|
20818
21528
|
options.mode = "thread";
|
|
20819
|
-
options.threadName =
|
|
21529
|
+
options.threadName = requireValue4(rest, token);
|
|
20820
21530
|
break;
|
|
20821
21531
|
default:
|
|
20822
21532
|
throw new Error(`Unknown collect option: ${token}`);
|
|
@@ -20827,7 +21537,7 @@ function parseCollectArgs(tokens) {
|
|
|
20827
21537
|
}
|
|
20828
21538
|
return { type: "collect" /* Collect */, ...options };
|
|
20829
21539
|
}
|
|
20830
|
-
function
|
|
21540
|
+
function requireValue4(tokens, optionName) {
|
|
20831
21541
|
const value = tokens.shift();
|
|
20832
21542
|
if (!value) {
|
|
20833
21543
|
throw new Error(`Missing value for ${optionName}`);
|
|
@@ -20968,6 +21678,11 @@ async function main() {
|
|
|
20968
21678
|
await handler.handle(commandArgs);
|
|
20969
21679
|
return;
|
|
20970
21680
|
}
|
|
21681
|
+
case "store" /* Store */: {
|
|
21682
|
+
const handler = new StoreCommandHandler();
|
|
21683
|
+
await handler.handle(commandArgs);
|
|
21684
|
+
return;
|
|
21685
|
+
}
|
|
20971
21686
|
case "app" /* App */: {
|
|
20972
21687
|
const handler = new AppCommandHandler();
|
|
20973
21688
|
await handler.handle(commandArgs);
|