@deepraxis/cli 0.3.0-dev.0d5636a → 0.3.0-dev.0d6e54c
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/COMMANDS.md +23 -2
- package/dist/praxis.js +2339 -240
- package/package.json +1 -1
package/dist/praxis.js
CHANGED
|
@@ -13978,18 +13978,27 @@ var require_public_api2 = __commonJS((exports) => {
|
|
|
13978
13978
|
exports.stringify = stringify;
|
|
13979
13979
|
});
|
|
13980
13980
|
|
|
13981
|
-
// ../../packages/praxis/
|
|
13981
|
+
// ../../packages/praxis/flags-client/src/flag-registry.generated.ts
|
|
13982
13982
|
var FLAGS;
|
|
13983
13983
|
var init_flag_registry_generated = __esm(() => {
|
|
13984
13984
|
FLAGS = {
|
|
13985
13985
|
"agent-cognition-idle-wake": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "genius", ticket: 540, expires: "2026-11-30", system: "flagship" },
|
|
13986
|
+
"agent-process-mode-base": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2365, expires: "2026-12-16", system: "devops" },
|
|
13987
|
+
"cognition-per-agent": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2506, expires: "2026-11-30", system: "devops" },
|
|
13986
13988
|
"cognition-weight-driven": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "praxis-bd", ticket: 1760, expires: "2026-12-05", system: "devops" },
|
|
13989
|
+
"computer-archive-volume": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2419, expires: "2026-11-30", system: "devops" },
|
|
13990
|
+
crm: { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_rv860m7z9h8szkgma56cd14n", ticket: 2179, expires: "2026-12-31", system: "devops" },
|
|
13987
13991
|
"delivery-rules-v2": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2048, expires: "2026-11-28", system: "devops" },
|
|
13992
|
+
"end-users": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2312, expires: "2026-12-15", system: "devops" },
|
|
13993
|
+
"letters-email-delivery": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2150, expires: "2026-11-29", system: "devops" },
|
|
13988
13994
|
"model-access-gate": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 1933, expires: "2026-12-15", system: "devops" },
|
|
13989
13995
|
"open-project": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "praxis-51", ticket: 1488, expires: "2026-11-25", system: "devops" },
|
|
13990
13996
|
"requests-never-hold": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2119, expires: "2026-11-29", system: "devops" },
|
|
13991
13997
|
"requests-v1": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2057, expires: "2026-11-28", system: "devops" },
|
|
13998
|
+
"resource-library": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "agent_97823517-ae48-422d-8abc-fa4d8bacd5cc", ticket: 2546, expires: "2026-11-30", system: "devops" },
|
|
13999
|
+
"router-diagnostics-telemetry": { kind: "OPS", type: "BOOLEAN", default: false, owner: "agent_7bc73c94-ffe8-482c-8f9f-2e40bc1c9951", ticket: 2559, expires: "2026-11-30", system: "devops" },
|
|
13992
14000
|
"router-precommit-hedge": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2052, expires: "2026-11-28", system: "devops" },
|
|
14001
|
+
"router-responses-hedge": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: 2149, expires: "2026-11-28", system: "devops" },
|
|
13993
14002
|
"search-provider-routing": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "praxis-98", ticket: 716, expires: "2026-12-31", system: "devops" },
|
|
13994
14003
|
"unit-live-probe": { kind: "RELEASE", type: "BOOLEAN", default: false, owner: "usr_t60d4g5z82rhbtbfrfxfbdxe", ticket: null, expires: "2026-11-19", system: "devops" }
|
|
13995
14004
|
};
|
|
@@ -14016,7 +14025,7 @@ function checkFlags(files, registry, today = new Date().toISOString().slice(0, 1
|
|
|
14016
14025
|
}
|
|
14017
14026
|
const registryFile = production.find((f) => f.path.endsWith("flag-registry.generated.ts"));
|
|
14018
14027
|
const registryLine = (key) => registryFile ? lineOf(registryFile.text, Math.max(0, registryFile.text.indexOf(`"${key}":`))) : 1;
|
|
14019
|
-
const add = (file, offset,
|
|
14028
|
+
const add = (file, offset, message2) => issues.push({ file: file.path, line: lineOf(file.text, offset), message: message2 });
|
|
14020
14029
|
const referencedKeysIn = (file) => {
|
|
14021
14030
|
for (const key of registered) {
|
|
14022
14031
|
const literal = new RegExp(`(?:"|')${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:"|')`);
|
|
@@ -14075,9 +14084,9 @@ function checkFlags(files, registry, today = new Date().toISOString().slice(0, 1
|
|
|
14075
14084
|
}
|
|
14076
14085
|
for (const key of registered)
|
|
14077
14086
|
if (!referenced.has(key))
|
|
14078
|
-
issues.push({ file: "packages/praxis/
|
|
14087
|
+
issues.push({ file: "packages/praxis/flags-client/src/flag-registry.generated.ts", line: registryLine(key), message: `registered flag "${key}" has no non-test code reference` });
|
|
14079
14088
|
for (const [key, def] of Object.entries(registry)) {
|
|
14080
|
-
const file = "packages/praxis/
|
|
14089
|
+
const file = "packages/praxis/flags-client/src/flag-registry.generated.ts";
|
|
14081
14090
|
const line = registryLine(key);
|
|
14082
14091
|
if (def.expires !== null && !isCalendarDate(def.expires))
|
|
14083
14092
|
issues.push({ file, line, message: `flag "${key}" expires must be YYYY-MM-DD` });
|
|
@@ -14105,7 +14114,7 @@ async function main() {
|
|
|
14105
14114
|
else
|
|
14106
14115
|
console.log(`Feature flag registry check passed (${Object.keys(FLAGS).length} registered flags).`);
|
|
14107
14116
|
}
|
|
14108
|
-
var isTest = (path) => /(^|\/)(spec|__tests__)(\/|$)|\.(test|spec)\.[cm]?[jt]sx?$/.test(path), lineOf = (
|
|
14117
|
+
var isTest = (path) => /(^|\/)(spec|__tests__)(\/|$)|\.(test|spec)\.[cm]?[jt]sx?$/.test(path), lineOf = (text3, offset) => text3.slice(0, offset).split(`
|
|
14109
14118
|
`).length, isCalendarDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(new Date(`${value}T00:00:00.000Z`).valueOf()) && new Date(`${value}T00:00:00.000Z`).toISOString().slice(0, 10) === value;
|
|
14110
14119
|
var init_check_flags = __esm(() => {
|
|
14111
14120
|
init_flag_registry_generated();
|
|
@@ -14234,7 +14243,7 @@ function renderRegistry(flags) {
|
|
|
14234
14243
|
const rows = [...flags].sort(compareKey);
|
|
14235
14244
|
return `// Generated by \`bun run flags:sync\`. Do not edit by hand.
|
|
14236
14245
|
// The two systems (ticket-704): develop config.flags.list is the "flagship" side, the DevOps platform project's own flags are the "devops" side. A key a DevOps copy shares with config stays flagship.
|
|
14237
|
-
import type { FlagKind } from "
|
|
14246
|
+
import type { FlagKind } from "@deepractice-ai/config-client";
|
|
14238
14247
|
|
|
14239
14248
|
type FlagMetadata = { readonly kind: FlagKind; readonly owner: string | null; readonly ticket: number | null; readonly expires: string | null; readonly system: "flagship" | "devops" };
|
|
14240
14249
|
export type FlagDefinition = FlagMetadata & (
|
|
@@ -14303,7 +14312,7 @@ async function checkRegistrySync(ports = {}) {
|
|
|
14303
14312
|
}
|
|
14304
14313
|
async function syncFlags(ports = {}) {
|
|
14305
14314
|
const registry = ports.registry ?? registryUrl;
|
|
14306
|
-
const write = ports.write ?? ((target,
|
|
14315
|
+
const write = ports.write ?? ((target, text3) => writeFile4(target, text3));
|
|
14307
14316
|
const log = ports.log ?? console.log;
|
|
14308
14317
|
const error = ports.error ?? console.error;
|
|
14309
14318
|
const devops = await (ports.devops ?? readDevopsFlags)();
|
|
@@ -14340,7 +14349,7 @@ var init_flags_sync = __esm(() => {
|
|
|
14340
14349
|
DEVOPS_KINDS = { release: "RELEASE", ops: "OPS", experiment: "EXPERIMENT", permission: "PERMISSION" };
|
|
14341
14350
|
DEVOPS_TYPES = { boolean: "BOOLEAN", string: "STRING", number: "NUMBER", json: "JSON", object: "JSON" };
|
|
14342
14351
|
REPO_ROOT = fileURLToPath(new URL("..", import.meta.url));
|
|
14343
|
-
registryUrl = new URL("../packages/praxis/
|
|
14352
|
+
registryUrl = new URL("../packages/praxis/flags-client/src/flag-registry.generated.ts", import.meta.url);
|
|
14344
14353
|
if (true)
|
|
14345
14354
|
main2().catch((error) => {
|
|
14346
14355
|
console.error(error instanceof Error ? error.message : String(error));
|
|
@@ -14540,9 +14549,10 @@ async function runEngineDelegation(delegation, options) {
|
|
|
14540
14549
|
}
|
|
14541
14550
|
|
|
14542
14551
|
// src/main.ts
|
|
14543
|
-
import { existsSync as existsSync4 } from "node:fs";
|
|
14552
|
+
import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync } from "node:fs";
|
|
14544
14553
|
import { mkdir as mkdir4, readFile as readFile7, readdir as readdir3, writeFile as writeFile5 } from "node:fs/promises";
|
|
14545
|
-
import { resolve as resolve11 } from "node:path";
|
|
14554
|
+
import { dirname as dirname10, join as join12, resolve as resolve11 } from "node:path";
|
|
14555
|
+
import { homedir as homedir3 } from "node:os";
|
|
14546
14556
|
import { pathToFileURL } from "node:url";
|
|
14547
14557
|
import { createHash as createHash5 } from "node:crypto";
|
|
14548
14558
|
import { spawn as spawn5 } from "node:child_process";
|
|
@@ -15600,8 +15610,8 @@ Idempotent. Access tokens revoked while the customer was blocked stay revoked; s
|
|
|
15600
15610
|
{
|
|
15601
15611
|
resource: "agent.agents.events",
|
|
15602
15612
|
method: "stream",
|
|
15603
|
-
summary: "Follow
|
|
15604
|
-
description: "Follow
|
|
15613
|
+
summary: "Follow an agent live",
|
|
15614
|
+
description: "Follow an agent live over Server-Sent Events. For a personal or general agent it is the stream of your own main session with that agent, the same stream sessions.events.stream opens, event_deltas[] previews included; read past events with agents.events.list. An assume agent has no main session: its body is its MCP connections, and this stream is its broadcast point, which every live connection of the agent hears at once. It carries two events, each with an SSE id: inbox.letter_delivered { letter_id, sender, sender_name, summary, thread, create_time } when a letter arrives (the letter stays unread; take it with the agent's inbox tool, the body is not in the event), and cognition.ritual_held { ritual, owner, title, engram, create_time } when a domain gives the agent a memory. Reconnect with the Last-Event-ID header to receive what you missed from a short recent buffer (about an hour); a first connection replays nothing, so read agents.inbox.letters.list for mail already waiting. {agent_id} takes the agent_… id, the eight character identity number or the handle; a service agent answers 400. Closing the stream only drops your subscription and does not stop the agent.",
|
|
15605
15615
|
http: "GET",
|
|
15606
15616
|
path: "/agent/v1/agents/{agent_id}/events/stream",
|
|
15607
15617
|
streaming: "always",
|
|
@@ -15627,6 +15637,40 @@ Idempotent. Access tokens revoked while the customer was blocked stay revoked; s
|
|
|
15627
15637
|
}
|
|
15628
15638
|
]
|
|
15629
15639
|
},
|
|
15640
|
+
{
|
|
15641
|
+
resource: "agent.agents.inbox.letters",
|
|
15642
|
+
method: "list",
|
|
15643
|
+
summary: "List an assume agent's waiting letters",
|
|
15644
|
+
description: "Check whether mail waits for an assume agent without taking it: answers unread, the count of delivered letters the agent has not read, and letters, the newest unread ones (id, sender address, summary, thread, create_time; never the body). Nothing is marked read, so calling it again answers the same until the agent reads its mail with its own inbox tool (praxis_assume_inbox, action \"read\"). Use it when something outside the agent has to learn that mail arrived: the local `praxis agent events wait` reads it once on start and after every reconnect to its agent's event stream, so no letter that arrived while nothing listened is missed. {agent_id} takes the agent_… id, the eight character identity number or the handle of an assume agent in your organization; any other kind answers 400 ASSUME_AGENT_REQUIRED. To read or answer the letters, use the agent's inbox tool, not this read. Example: GET /agent/v1/agents/R1M9TQ2X/inbox/letters?unread=true&limit=5.",
|
|
15645
|
+
http: "GET",
|
|
15646
|
+
path: "/agent/v1/agents/{agent_id}/inbox/letters",
|
|
15647
|
+
streaming: "no",
|
|
15648
|
+
pagination: false,
|
|
15649
|
+
pathParams: [
|
|
15650
|
+
{
|
|
15651
|
+
name: "agent_id",
|
|
15652
|
+
sdkName: "agent_id",
|
|
15653
|
+
description: "The assume agent: its agent_… id, eight character identity number or handle, from agents.list or the praxis-assume MCP URL; resolved in your organization. Also accepts an 8-character identity number (0–9, A–Z); malformed, absent and foreign references return 404, and response ids always use agent_…."
|
|
15654
|
+
}
|
|
15655
|
+
],
|
|
15656
|
+
query: [
|
|
15657
|
+
{
|
|
15658
|
+
name: "unread",
|
|
15659
|
+
type: "boolean",
|
|
15660
|
+
enum: [
|
|
15661
|
+
true
|
|
15662
|
+
],
|
|
15663
|
+
required: false,
|
|
15664
|
+
description: "Only true is accepted, which is also the default; this read lists waiting (unread) letters and nothing else."
|
|
15665
|
+
},
|
|
15666
|
+
{
|
|
15667
|
+
name: "limit",
|
|
15668
|
+
type: "integer",
|
|
15669
|
+
required: false,
|
|
15670
|
+
description: "How many of the newest unread letters to return, 1 to 50 (default 20); unread always counts every waiting letter."
|
|
15671
|
+
}
|
|
15672
|
+
]
|
|
15673
|
+
},
|
|
15630
15674
|
{
|
|
15631
15675
|
resource: "agent.agents.unarchive",
|
|
15632
15676
|
method: "create",
|
|
@@ -16994,7 +17038,7 @@ delete it. Omit the field to preserve.`
|
|
|
16994
17038
|
summary: "List Session Artifacts (Extension)",
|
|
16995
17039
|
description: `List the files this session delivered; an end-customer token reads its own session.
|
|
16996
17040
|
|
|
16997
|
-
Own-face extension. Returns { data: Artifact[] } ordered by create_time. Each artifact is one file in the session outputs directory with id, name, version, parts, source_hrefs, create_time and update_time. Delivering the same path again keeps the id and adds one to version. Files are captured seconds after the turn ends, so artifacts appear after session.status_idle; also watch the agent.artifact_delivered event. Whoever may read the session may read its artifacts; a session that is missing or not yours returns 404.`,
|
|
17041
|
+
Own-face extension. Returns { data: Artifact[] } ordered by create_time. Each artifact is one file in the session outputs directory, or one canvas or media asset the reply pointed at (a part with kind object carrying object_type, object_id and href; one artifact per object, pointing at it again adds no version), with id, name, version, parts, source_hrefs, create_time and update_time. Delivering the same path again keeps the id and adds one to version. Files are captured seconds after the turn ends, so artifacts appear after session.status_idle; also watch the agent.artifact_delivered event. Whoever may read the session may read its artifacts; a session that is missing or not yours returns 404.`,
|
|
16998
17042
|
http: "GET",
|
|
16999
17043
|
path: "/agent/v1/sessions/{session_id}/artifacts",
|
|
17000
17044
|
streaming: "no",
|
|
@@ -17014,7 +17058,7 @@ Own-face extension. Returns { data: Artifact[] } ordered by create_time. Each ar
|
|
|
17014
17058
|
summary: "Create Artifact Content URL (Extension)",
|
|
17015
17059
|
description: `Mint a short-lived download address for one file of an artifact.
|
|
17016
17060
|
|
|
17017
|
-
Own-face extension. The body is optional: part (index into the artifact parts, default 0) and ttl_seconds (60 to 300, default 300). Returns { url, expire_time }. The address works for minutes; do not store or log it. An unknown artifact or an out-of-range part returns 404 ARTIFACT_NOT_FOUND, a session that is missing or not yours returns 404, and a ttl_seconds outside 60 to 300 returns 400.`,
|
|
17061
|
+
Own-face extension. The body is optional: part (index into the artifact parts, default 0) and ttl_seconds (60 to 300, default 300). Returns { url, expire_time }. The address works for minutes; do not store or log it. For an object part the address serves a snapshot picture of a canvas or the own bytes of the asset; an object that no longer exists returns 404 ARTIFACT_NOT_FOUND and a failing share service returns 502. An unknown artifact or an out-of-range part returns 404 ARTIFACT_NOT_FOUND, a session that is missing or not yours returns 404, and a ttl_seconds outside 60 to 300 returns 400.`,
|
|
17018
17062
|
http: "POST",
|
|
17019
17063
|
path: "/agent/v1/sessions/{session_id}/artifacts/{artifact_id}/content_url",
|
|
17020
17064
|
streaming: "no",
|
|
@@ -17233,7 +17277,7 @@ Praxis extension available only on /agent/v1, following Claude Agent SDK getCont
|
|
|
17233
17277
|
resource: "agent.sessions.events",
|
|
17234
17278
|
method: "list",
|
|
17235
17279
|
summary: "List session events",
|
|
17236
|
-
description: "Read the event history of a session as a page of events, oldest first by default (order=desc for newest first). Use it after sending a message to collect the reply, to find tool calls that wait for approval or client custom tool results (session.status_idle with stop_reason requires_action lists their event_ids; a request nobody answered within 24 hours is settled as unanswered and the session goes idle with stop_reason request_expired, which the /anthropic/v1 face shows as end_turn), or to audit a run; to follow a running session live use sessions.events.stream instead. Filter by types and by a created_at range on processed_at; pages hold at most 100 events (default 20) and next_page continues. A failed run emits session.error before session.status_terminated. Native history also includes user.steer, user.withdraw, system.notification, session.forked, session.goal_changed and session.goal_verification; these are not accepted by the /anthropic/v1 event-type filter. This operation addresses one session — normally a worker session an agent dispatched; to talk to a personal or general agent itself, use agents.events.list instead. In the path, session_id may also be `main` (your own main session with that agent) or a short session name, and either alias then requires agent_id with the agent_… id, the eight character identity number or the handle; only the own face /agent/v1 accepts an alias, /anthropic/v1 requires a real sesn_… id.",
|
|
17280
|
+
description: "Read the event history of a session as a page of events, oldest first by default (order=desc for newest first). Use it after sending a message to collect the reply, to find tool calls that wait for approval or client custom tool results (session.status_idle with stop_reason requires_action lists their event_ids; a request nobody answered within 24 hours is settled as unanswered and the session goes idle with stop_reason request_expired, which the /anthropic/v1 face shows as end_turn), or to audit a run; to follow a running session live use sessions.events.stream instead. Filter by types and by a created_at range on processed_at; pages hold at most 100 events (default 20) and next_page continues. A failed run emits session.error before session.status_terminated. Native history also includes user.steer, user.withdraw, system.notification, system.notification_suppressed (pending background notifications that hit the wake quota and started no run), system.notification_recorded, session.forked, session.goal_changed and session.goal_verification; these are not accepted by the /anthropic/v1 event-type filter. This operation addresses one session — normally a worker session an agent dispatched; to talk to a personal or general agent itself, use agents.events.list instead. In the path, session_id may also be `main` (your own main session with that agent) or a short session name, and either alias then requires agent_id with the agent_… id, the eight character identity number or the handle; only the own face /agent/v1 accepts an alias, /anthropic/v1 requires a real sesn_… id.",
|
|
17237
17281
|
http: "GET",
|
|
17238
17282
|
path: "/agent/v1/sessions/{session_id}/events",
|
|
17239
17283
|
streaming: "no",
|
|
@@ -30271,7 +30315,7 @@ The default is return=minimal: success returns HTTP 201 with an empty body. Send
|
|
|
30271
30315
|
resource: "file.uploads",
|
|
30272
30316
|
method: "createSigned",
|
|
30273
30317
|
summary: "Create a one-time upload URL",
|
|
30274
|
-
description: "Upload a local file of up to 20 GiB from a coding agent without sending bytes through the model. Provide filename (the stored basename), exact byte count and MIME type. Up to 104857600 bytes, PUT the file to url with curl -T photo.png -H 'Content-Type: image/png' '<url>'; success returns 201 with the file object, and reuse returns 410 CAPABILITY_USED. Above that threshold, split the file into part_size chunks (default 64000000 bytes) and PUT each chunk to its numbered parts[].url in any order; an interrupted client GETs status_url to see the received parts and resends only what is missing, then POSTs complete_url without a body. Part PUTs return 200; completion returns 201 with the file object, including its state, or 400 if a part is missing. A processing file can be polled with files.retrieve until active. Identical part bytes may be retried; changed bytes at the same number return 400. Completion reuse returns 410 CAPABILITY_USED. Each PUT requires the exact signed Content-Length; single-PUT Content-Type must match content_type or be omitted. Expired, revoked, invalid
|
|
30318
|
+
description: "Upload a local file of up to 20 GiB from a coding agent without sending bytes through the model. Provide filename (the stored basename), exact byte count and MIME type. Up to 104857600 bytes, PUT the file to url with curl -T photo.png -H 'Content-Type: image/png' '<url>'; success returns 201 with the file object, and reuse returns 410 CAPABILITY_USED. Above that threshold, split the file into part_size chunks (default 64000000 bytes) and PUT each chunk to its numbered parts[].url in any order; an interrupted client GETs status_url to see the received parts and resends only what is missing, then POSTs complete_url without a body. Part PUTs return 200; completion returns 201 with the file object, including its state, or 400 if a part is missing. A processing file can be polled with files.retrieve until active. Identical part bytes may be retried; changed bytes at the same number return 400. Completion reuse returns 410 CAPABILITY_USED. Each PUT requires the exact signed Content-Length; single-PUT Content-Type must match content_type or be omitted. Expired, revoked, invalid or cross-organization URLs return 404, and so does a link whose upload record no longer exists. A URL that is authentic but names another action returns 403 CAPABILITY_MISMATCH: a status link posted to complete_url answers it, and so does a completion link fetched as status_url. URL lifetime defaults to 900 seconds for single PUT or 604800 (7 days) for multipart, at most 604800; all multipart URLs, including status_url, share an expiry. Multipart creation reserves storage quota. Issuance requires the same unscoped credential as direct file creation. Each issuance creates a new upload and is not idempotent. Example body: {\"filename\":\"photo.png\",\"bytes\":2048,\"content_type\":\"image/png\"}.",
|
|
30275
30319
|
http: "POST",
|
|
30276
30320
|
path: "/file/v1/uploads/signed",
|
|
30277
30321
|
streaming: "no",
|
|
@@ -31995,6 +32039,69 @@ The default is return=minimal: success returns HTTP 201 with an empty body. Send
|
|
|
31995
32039
|
]
|
|
31996
32040
|
}
|
|
31997
32041
|
},
|
|
32042
|
+
{
|
|
32043
|
+
resource: "media.libraries.assets.hls",
|
|
32044
|
+
method: "list",
|
|
32045
|
+
summary: "Get HLS renditions",
|
|
32046
|
+
description: "Read how ready a video asset’s on-demand ladder is, rung by rung, without building anything. Use library_id and asset_id as everywhere else. The answer names the asset, its current version, the asset’s own facts (resource_type, is_audio and duration) and one entry per recorded rung — name, height, the first indexed piece’s width, the rung’s bitrate and stored bytes, and its state (processing while pieces run, ready when every piece is ready, failed when a piece gave up). A ladder that was never requested, and an asset that is not a video, answer an empty renditions rather than an error. This read mints no capability and signs nothing, so play the ladder through the content service, which issues the short-lived play address for the current version. Example: GET /media/v1/libraries/lib_example/assets/9dfa312ef9bc4b00816339b598b1152c/hls.",
|
|
32047
|
+
http: "GET",
|
|
32048
|
+
path: "/media/v1/libraries/{library_id}/assets/{asset_id}/hls",
|
|
32049
|
+
streaming: "no",
|
|
32050
|
+
pagination: false,
|
|
32051
|
+
pathParams: [
|
|
32052
|
+
{
|
|
32053
|
+
name: "library_id",
|
|
32054
|
+
sdkName: "library_id",
|
|
32055
|
+
description: "Library ID returned by creation."
|
|
32056
|
+
},
|
|
32057
|
+
{
|
|
32058
|
+
name: "asset_id",
|
|
32059
|
+
sdkName: "asset_id",
|
|
32060
|
+
description: "32-character asset ID."
|
|
32061
|
+
}
|
|
32062
|
+
],
|
|
32063
|
+
query: []
|
|
32064
|
+
},
|
|
32065
|
+
{
|
|
32066
|
+
resource: "media.libraries.assets.hls",
|
|
32067
|
+
method: "create",
|
|
32068
|
+
summary: "Request HLS renditions",
|
|
32069
|
+
description: "Build a video asset’s adaptive HLS ladder for its current version, so one asset plays at several clarities on an ordinary player. Use library_id from creation or listing and the asset_id of a video asset; the ladder belongs to the version the asset has now, and a later version gets its own. heights names the rungs to build: a non-empty subset of 480, 720 and 1080 with no repeats, or omitted to build all three. The ladder never upscales — a rung above the source’s short side is dropped, and a list entirely above it keeps its lowest rung. The call is asynchronous and starts paid transcoding: the work runs as the video-transcode-hls model, one piece per rung per ten minutes of source, and it is charged per output minute at that model’s published price to the organization that owns the asset (ADR-146 §5) — a rung the source cannot carry, and a failed rung, are not charged. A source longer than eight hours (28800 seconds) is refused with SOURCE_TOO_LONG before anything is planned. Repeating the call is safe: a rung already processing, ready or failed is left as it is and is never encoded twice. The response is 202 with the asset_id, its current version and one entry per rung — name, height, width, bitrate, bytes and state, where processing means the rung is still being encoded, ready means it plays and failed means it gave up and can be retried by asking again. Poll GET /media/v1/libraries/{library_id}/assets/{asset_id}/hls until every rung is ready, then play the ladder through the content service, which mints the short-lived play address. Example: POST /media/v1/libraries/lib_example/assets/9dfa312ef9bc4b00816339b598b1152c/hls with {\"heights\":[480,720,1080]}.",
|
|
32070
|
+
http: "POST",
|
|
32071
|
+
path: "/media/v1/libraries/{library_id}/assets/{asset_id}/hls",
|
|
32072
|
+
streaming: "no",
|
|
32073
|
+
pagination: false,
|
|
32074
|
+
pathParams: [
|
|
32075
|
+
{
|
|
32076
|
+
name: "library_id",
|
|
32077
|
+
sdkName: "library_id",
|
|
32078
|
+
description: "Library ID returned by creation."
|
|
32079
|
+
},
|
|
32080
|
+
{
|
|
32081
|
+
name: "asset_id",
|
|
32082
|
+
sdkName: "asset_id",
|
|
32083
|
+
description: "32-character asset ID."
|
|
32084
|
+
}
|
|
32085
|
+
],
|
|
32086
|
+
query: [],
|
|
32087
|
+
body: {
|
|
32088
|
+
required: true,
|
|
32089
|
+
fields: [
|
|
32090
|
+
{
|
|
32091
|
+
name: "heights",
|
|
32092
|
+
type: "array",
|
|
32093
|
+
itemType: "integer",
|
|
32094
|
+
enum: [
|
|
32095
|
+
480,
|
|
32096
|
+
720,
|
|
32097
|
+
1080
|
|
32098
|
+
],
|
|
32099
|
+
required: false,
|
|
32100
|
+
description: "The clarity rungs to build: a non-empty subset of 480, 720 and 1080 with no repeats. Omitted or empty builds all three. The ladder never upscales, so a rung above the source’s short side is dropped."
|
|
32101
|
+
}
|
|
32102
|
+
]
|
|
32103
|
+
}
|
|
32104
|
+
},
|
|
31998
32105
|
{
|
|
31999
32106
|
resource: "media.assets",
|
|
32000
32107
|
method: "lineage",
|
|
@@ -38495,6 +38602,570 @@ for more details.`
|
|
|
38495
38602
|
}
|
|
38496
38603
|
]
|
|
38497
38604
|
},
|
|
38605
|
+
{
|
|
38606
|
+
resource: "registry.installations",
|
|
38607
|
+
method: "delete",
|
|
38608
|
+
summary: "Remove an installation",
|
|
38609
|
+
description: "把包从目标上卸下来,并删掉这条安装记录:技能从智能体的技能列表里移除,插件从电脑上卸载。目标那边已经没有它时也算完成。包本身和它的版本不受影响,之后可以重新安装。记录删除后重发会 404,所以删除前先用 installations.list 确认。",
|
|
38610
|
+
http: "DELETE",
|
|
38611
|
+
path: "/registry/v1/installations/{installation_id}",
|
|
38612
|
+
streaming: "no",
|
|
38613
|
+
pagination: false,
|
|
38614
|
+
pathParams: [
|
|
38615
|
+
{
|
|
38616
|
+
name: "installation_id",
|
|
38617
|
+
sdkName: "installation_id",
|
|
38618
|
+
description: "安装记录的标识,来自 packages.installations.list 或 packages.installations.create 返回的 id(ins_ 开头);不要传包或目标的 id。"
|
|
38619
|
+
}
|
|
38620
|
+
],
|
|
38621
|
+
query: []
|
|
38622
|
+
},
|
|
38623
|
+
{
|
|
38624
|
+
resource: "registry.installations",
|
|
38625
|
+
method: "update",
|
|
38626
|
+
summary: "Update an installation",
|
|
38627
|
+
description: "把一条安装记录换到另一个版本。技能可以换到任何未撤回的版本(升级或回退),version 省略时换到最新版;插件只能换到库里的最新版本,version 给了也必须等于最新版。撤回的版本不能换过去。对账为 missing 的记录用它可以重新装回去。同名冲突和 20 个技能上限的规则与安装时相同。",
|
|
38628
|
+
http: "POST",
|
|
38629
|
+
path: "/registry/v1/installations/{installation_id}:update",
|
|
38630
|
+
streaming: "no",
|
|
38631
|
+
pagination: false,
|
|
38632
|
+
pathParams: [
|
|
38633
|
+
{
|
|
38634
|
+
name: "installation_id",
|
|
38635
|
+
sdkName: "installation_id",
|
|
38636
|
+
description: "安装记录的标识,来自 packages.installations.list 或 packages.installations.create 返回的 id(ins_ 开头);不要传包或目标的 id。"
|
|
38637
|
+
}
|
|
38638
|
+
],
|
|
38639
|
+
query: [],
|
|
38640
|
+
body: {
|
|
38641
|
+
required: true,
|
|
38642
|
+
fields: [
|
|
38643
|
+
{
|
|
38644
|
+
name: "version",
|
|
38645
|
+
type: "string",
|
|
38646
|
+
required: false,
|
|
38647
|
+
description: "要换到的版本号,完整 semver;省略时换到最新版;插件给了也必须等于最新版,撤回的版本不能换。"
|
|
38648
|
+
}
|
|
38649
|
+
]
|
|
38650
|
+
}
|
|
38651
|
+
},
|
|
38652
|
+
{
|
|
38653
|
+
resource: "registry.packages",
|
|
38654
|
+
method: "retrieve",
|
|
38655
|
+
summary: "Retrieve package",
|
|
38656
|
+
description: "读一个包的元数据:种类、所属库、当前 latest_version、作者、标签和累计下载量。package_id 来自 packages.list 或 packages.create;另一个组织或不存在都返回 404。",
|
|
38657
|
+
http: "GET",
|
|
38658
|
+
path: "/registry/v1/packages/{package_id}",
|
|
38659
|
+
streaming: "no",
|
|
38660
|
+
pagination: false,
|
|
38661
|
+
pathParams: [
|
|
38662
|
+
{
|
|
38663
|
+
name: "package_id",
|
|
38664
|
+
sdkName: "package_id",
|
|
38665
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38666
|
+
}
|
|
38667
|
+
],
|
|
38668
|
+
query: []
|
|
38669
|
+
},
|
|
38670
|
+
{
|
|
38671
|
+
resource: "registry.packages.installations",
|
|
38672
|
+
method: "list",
|
|
38673
|
+
summary: "List installations",
|
|
38674
|
+
description: "列出这个包装在哪些智能体和电脑上。每次读取都会和目标那边对账,以目标现在的实际情况为准,所以每条记录的 state 是读取这一刻的结论:installed 表示目标上有它且版本与记录一致;drifted 表示目标上有它但版本不同,此时 version 显示目标上的版本;missing 表示目标上已经没有它(被人在智能体或电脑那边删掉了),记录仍保留,可以用 installations.delete 清掉,或用 installations.update 重新装回;unknown 表示这次问不到目标,不代表没装,稍后重读。withdrawn 表示这条记录的版本已被撤回。一次返回全部记录,没有分页,按创建时间排序。",
|
|
38675
|
+
http: "GET",
|
|
38676
|
+
path: "/registry/v1/packages/{package_id}/installations",
|
|
38677
|
+
streaming: "no",
|
|
38678
|
+
pagination: false,
|
|
38679
|
+
pathParams: [
|
|
38680
|
+
{
|
|
38681
|
+
name: "package_id",
|
|
38682
|
+
sdkName: "package_id",
|
|
38683
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38684
|
+
}
|
|
38685
|
+
],
|
|
38686
|
+
query: []
|
|
38687
|
+
},
|
|
38688
|
+
{
|
|
38689
|
+
resource: "registry.packages.installations",
|
|
38690
|
+
method: "create",
|
|
38691
|
+
summary: "Install a package",
|
|
38692
|
+
description: "把一个包装到目标上:技能装到智能体(agent_ids),插件装到电脑(computer_ids),一次最多 50 个目标;目标种类给错会被拒(400),包的种类可从 packages.retrieve 的 kind 得知。技能装的是具体版本,version 省略时装最新版,之后不会自动升级,要换版本用 installations.update。插件只能装库里的最新版本,version 若给了就必须等于最新版,否则 FAILED_PRECONDITION。撤回的版本不能新装。同一目标重复装同一个包不会报错,而是把它移到这个版本。技能被拒的情形:智能体上已有同名的另一个技能(名字冲突),或这个智能体已经有 20 个技能。各目标独立处理:只要有一个成功就返回 201,成功的在 data 里,失败的目标在 errors 里逐个列出 target_id、code 和 message,按消息修正后只对失败的目标重发;全部失败时不返回 201,而是按第一个失败返回错误状态。装到智能体或电脑上要求调用者本人有权限,权限不足会出现在该目标的 errors 里。",
|
|
38693
|
+
http: "POST",
|
|
38694
|
+
path: "/registry/v1/packages/{package_id}/installations",
|
|
38695
|
+
streaming: "no",
|
|
38696
|
+
pagination: false,
|
|
38697
|
+
pathParams: [
|
|
38698
|
+
{
|
|
38699
|
+
name: "package_id",
|
|
38700
|
+
sdkName: "package_id",
|
|
38701
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38702
|
+
}
|
|
38703
|
+
],
|
|
38704
|
+
query: [],
|
|
38705
|
+
body: {
|
|
38706
|
+
required: true,
|
|
38707
|
+
fields: [
|
|
38708
|
+
{
|
|
38709
|
+
name: "agent_ids",
|
|
38710
|
+
type: "array",
|
|
38711
|
+
itemType: "string",
|
|
38712
|
+
required: false,
|
|
38713
|
+
description: "要装到的智能体标识,1 到 50 个,重复的会合并;只用于技能,来自智能体列表的 id。"
|
|
38714
|
+
},
|
|
38715
|
+
{
|
|
38716
|
+
name: "computer_ids",
|
|
38717
|
+
type: "array",
|
|
38718
|
+
itemType: "string",
|
|
38719
|
+
required: false,
|
|
38720
|
+
description: "要装到的电脑标识,1 到 50 个,重复的会合并;只用于插件,来自电脑列表的 id。"
|
|
38721
|
+
},
|
|
38722
|
+
{
|
|
38723
|
+
name: "version",
|
|
38724
|
+
type: "string",
|
|
38725
|
+
required: false,
|
|
38726
|
+
description: "要装的版本号,完整 semver;省略时装最新版;插件给了也必须等于最新版,撤回的版本不能装。"
|
|
38727
|
+
}
|
|
38728
|
+
]
|
|
38729
|
+
}
|
|
38730
|
+
},
|
|
38731
|
+
{
|
|
38732
|
+
resource: "registry.packages.versions",
|
|
38733
|
+
method: "list",
|
|
38734
|
+
summary: "List versions",
|
|
38735
|
+
description: "列出一个包的所有版本,含已撤回的。撤回的版本仍在列表里(它占着版本号),withdrawn 为 true,并带 withdraw_time。按发布顺序返回。",
|
|
38736
|
+
http: "GET",
|
|
38737
|
+
path: "/registry/v1/packages/{package_id}/versions",
|
|
38738
|
+
streaming: "no",
|
|
38739
|
+
pagination: true,
|
|
38740
|
+
pathParams: [
|
|
38741
|
+
{
|
|
38742
|
+
name: "package_id",
|
|
38743
|
+
sdkName: "package_id",
|
|
38744
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38745
|
+
}
|
|
38746
|
+
],
|
|
38747
|
+
query: [
|
|
38748
|
+
{
|
|
38749
|
+
name: "page_size",
|
|
38750
|
+
type: "integer",
|
|
38751
|
+
required: false,
|
|
38752
|
+
description: "每页返回多少条,1 到 100;省略时默认 20。超过 100 会被截到 100。"
|
|
38753
|
+
},
|
|
38754
|
+
{
|
|
38755
|
+
name: "cursor",
|
|
38756
|
+
type: "string",
|
|
38757
|
+
required: false,
|
|
38758
|
+
description: "上一页返回的 next_cursor,用来取下一页;第一页省略它,next_cursor 为 null 时停止翻页。"
|
|
38759
|
+
}
|
|
38760
|
+
]
|
|
38761
|
+
},
|
|
38762
|
+
{
|
|
38763
|
+
resource: "registry.packages.versions",
|
|
38764
|
+
method: "create",
|
|
38765
|
+
summary: "Publish a version",
|
|
38766
|
+
description: "给一个已有的包发新版本。请求体与 packages.create 相同(multipart:version 必填,archive 或 files 给内容),但种类和名字沿用这个包,不再从上传内容重判。version 必须比已发布的最高版本高(撤回的版本也占号,不能复用);比它低或相等返回 FAILED_PRECONDITION。一个包的作者和标签不随新版本改变。",
|
|
38767
|
+
http: "POST",
|
|
38768
|
+
path: "/registry/v1/packages/{package_id}/versions",
|
|
38769
|
+
streaming: "no",
|
|
38770
|
+
pagination: false,
|
|
38771
|
+
multipart: true,
|
|
38772
|
+
pathParams: [
|
|
38773
|
+
{
|
|
38774
|
+
name: "package_id",
|
|
38775
|
+
sdkName: "package_id",
|
|
38776
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38777
|
+
}
|
|
38778
|
+
],
|
|
38779
|
+
query: [],
|
|
38780
|
+
body: {
|
|
38781
|
+
required: true,
|
|
38782
|
+
fields: [
|
|
38783
|
+
{
|
|
38784
|
+
name: "version",
|
|
38785
|
+
type: "string",
|
|
38786
|
+
required: true,
|
|
38787
|
+
description: "要发布的版本号,完整 semver,例如 1.2.0;每个包内必须严格递增,撤回的版本也占号。"
|
|
38788
|
+
},
|
|
38789
|
+
{
|
|
38790
|
+
name: "archive",
|
|
38791
|
+
type: "string",
|
|
38792
|
+
required: false,
|
|
38793
|
+
description: "一个 zip 文件,内含包的内容;与 files 二选一。单个顶层目录会被剥掉。"
|
|
38794
|
+
},
|
|
38795
|
+
{
|
|
38796
|
+
name: "files",
|
|
38797
|
+
type: "array",
|
|
38798
|
+
itemType: "string",
|
|
38799
|
+
required: false,
|
|
38800
|
+
description: "直接上传的一组文件,每个 part 的 filename 是相对路径;与 archive 二选一。"
|
|
38801
|
+
},
|
|
38802
|
+
{
|
|
38803
|
+
name: "title",
|
|
38804
|
+
type: "string",
|
|
38805
|
+
required: false,
|
|
38806
|
+
description: "给人看的标题;省略时从包内容里取。"
|
|
38807
|
+
},
|
|
38808
|
+
{
|
|
38809
|
+
name: "description",
|
|
38810
|
+
type: "string",
|
|
38811
|
+
required: false,
|
|
38812
|
+
description: "包说明;省略时从包内容里取。"
|
|
38813
|
+
},
|
|
38814
|
+
{
|
|
38815
|
+
name: "tags",
|
|
38816
|
+
type: "string",
|
|
38817
|
+
required: false,
|
|
38818
|
+
description: "逗号分隔的标签,例如 review,quality;省略时没有标签。"
|
|
38819
|
+
}
|
|
38820
|
+
]
|
|
38821
|
+
}
|
|
38822
|
+
},
|
|
38823
|
+
{
|
|
38824
|
+
resource: "registry.packages.versions",
|
|
38825
|
+
method: "retrieveArchive",
|
|
38826
|
+
summary: "Download version archive",
|
|
38827
|
+
description: "下载一个版本的完整 zip 归档,用来整包安装或转存。每次调用都计入这个包的 downloads,所以不要为了看内容而反复拉 archive——先读 contents,只取需要的文件用 files 下载。",
|
|
38828
|
+
http: "GET",
|
|
38829
|
+
path: "/registry/v1/packages/{package_id}/versions/{version}/archive",
|
|
38830
|
+
streaming: "no",
|
|
38831
|
+
pagination: false,
|
|
38832
|
+
pathParams: [
|
|
38833
|
+
{
|
|
38834
|
+
name: "package_id",
|
|
38835
|
+
sdkName: "package_id",
|
|
38836
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38837
|
+
},
|
|
38838
|
+
{
|
|
38839
|
+
name: "version",
|
|
38840
|
+
sdkName: "version",
|
|
38841
|
+
description: "要读的版本号,来自 versions.list 或 versions.create 返回的 version;必须是完整 semver,形如 1.2.0,不接受 latest 或范围。"
|
|
38842
|
+
}
|
|
38843
|
+
],
|
|
38844
|
+
query: []
|
|
38845
|
+
},
|
|
38846
|
+
{
|
|
38847
|
+
resource: "registry.packages.versions.contents",
|
|
38848
|
+
method: "list",
|
|
38849
|
+
summary: "List version contents",
|
|
38850
|
+
description: "列出一个版本解压后的文件清单(路径和大小),用来在不下载整个包的前提下看它包含什么。路径是相对包根的,例如 SKILL.md 或 plugin/skills/review.md。已撤回的版本仍可读清单。",
|
|
38851
|
+
http: "GET",
|
|
38852
|
+
path: "/registry/v1/packages/{package_id}/versions/{version}/contents",
|
|
38853
|
+
streaming: "no",
|
|
38854
|
+
pagination: false,
|
|
38855
|
+
pathParams: [
|
|
38856
|
+
{
|
|
38857
|
+
name: "package_id",
|
|
38858
|
+
sdkName: "package_id",
|
|
38859
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38860
|
+
},
|
|
38861
|
+
{
|
|
38862
|
+
name: "version",
|
|
38863
|
+
sdkName: "version",
|
|
38864
|
+
description: "要读的版本号,来自 versions.list 或 versions.create 返回的 version;必须是完整 semver,形如 1.2.0,不接受 latest 或范围。"
|
|
38865
|
+
}
|
|
38866
|
+
],
|
|
38867
|
+
query: []
|
|
38868
|
+
},
|
|
38869
|
+
{
|
|
38870
|
+
resource: "registry.packages.versions.files",
|
|
38871
|
+
method: "retrieve",
|
|
38872
|
+
summary: "Download a file",
|
|
38873
|
+
description: "下载一个版本里的单个文件,返回原始字节。path 是 contents 给出的路径,可以含斜杠(例如 plugin/skills/review.md)。用它按文件取内容,装到磁盘上时保留这个相对路径。不计入 downloads。",
|
|
38874
|
+
http: "GET",
|
|
38875
|
+
path: "/registry/v1/packages/{package_id}/versions/{version}/files/{path}",
|
|
38876
|
+
streaming: "no",
|
|
38877
|
+
pagination: false,
|
|
38878
|
+
pathParams: [
|
|
38879
|
+
{
|
|
38880
|
+
name: "package_id",
|
|
38881
|
+
sdkName: "package_id",
|
|
38882
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38883
|
+
},
|
|
38884
|
+
{
|
|
38885
|
+
name: "version",
|
|
38886
|
+
sdkName: "version",
|
|
38887
|
+
description: "要读的版本号,来自 versions.list 或 versions.create 返回的 version;必须是完整 semver,形如 1.2.0,不接受 latest 或范围。"
|
|
38888
|
+
},
|
|
38889
|
+
{
|
|
38890
|
+
name: "path",
|
|
38891
|
+
sdkName: "path",
|
|
38892
|
+
description: "版本内的相对文件路径,取自 contents 返回的 path,可以含斜杠(例如 plugin/skills/review.md);不要以 / 开头。"
|
|
38893
|
+
}
|
|
38894
|
+
],
|
|
38895
|
+
query: []
|
|
38896
|
+
},
|
|
38897
|
+
{
|
|
38898
|
+
resource: "registry.packages.versions",
|
|
38899
|
+
method: "withdraw",
|
|
38900
|
+
summary: "Withdraw a version",
|
|
38901
|
+
description: "撤回一个版本。撤回后它不再是 latest、不能被新装;已经装好的照常可用。版本号仍被占着,不能再用它发新版本。已经撤回的版本再撤回会返回 FAILED_PRECONDITION。撤回是不可逆的:要重新提供这个版本,用更高的版本号重新发布。",
|
|
38902
|
+
http: "POST",
|
|
38903
|
+
path: "/registry/v1/packages/{package_id}/versions/{version}:withdraw",
|
|
38904
|
+
streaming: "no",
|
|
38905
|
+
pagination: false,
|
|
38906
|
+
pathParams: [
|
|
38907
|
+
{
|
|
38908
|
+
name: "package_id",
|
|
38909
|
+
sdkName: "package_id",
|
|
38910
|
+
description: "包的标识,来自 repositories.packages.list 或 repositories.packages.create 返回的 id;不要传包名。"
|
|
38911
|
+
},
|
|
38912
|
+
{
|
|
38913
|
+
name: "version",
|
|
38914
|
+
sdkName: "version",
|
|
38915
|
+
description: "要读的版本号,来自 versions.list 或 versions.create 返回的 version;必须是完整 semver,形如 1.2.0,不接受 latest 或范围。"
|
|
38916
|
+
}
|
|
38917
|
+
],
|
|
38918
|
+
query: []
|
|
38919
|
+
},
|
|
38920
|
+
{
|
|
38921
|
+
resource: "registry.repositories",
|
|
38922
|
+
method: "list",
|
|
38923
|
+
summary: "List repositories",
|
|
38924
|
+
description: "列出这个组织现有的库,默认库也在其中。库很少,一页通常装得下;用 next_cursor 翻页。先在这里拿到 repository_id,再用它列出或发布包。",
|
|
38925
|
+
http: "GET",
|
|
38926
|
+
path: "/registry/v1/repositories",
|
|
38927
|
+
streaming: "no",
|
|
38928
|
+
pagination: true,
|
|
38929
|
+
pathParams: [],
|
|
38930
|
+
query: [
|
|
38931
|
+
{
|
|
38932
|
+
name: "page_size",
|
|
38933
|
+
type: "integer",
|
|
38934
|
+
required: false,
|
|
38935
|
+
description: "每页返回多少条,1 到 100;省略时默认 20。超过 100 会被截到 100。"
|
|
38936
|
+
},
|
|
38937
|
+
{
|
|
38938
|
+
name: "cursor",
|
|
38939
|
+
type: "string",
|
|
38940
|
+
required: false,
|
|
38941
|
+
description: "上一页返回的 next_cursor,用来取下一页;第一页省略它,next_cursor 为 null 时停止翻页。"
|
|
38942
|
+
}
|
|
38943
|
+
]
|
|
38944
|
+
},
|
|
38945
|
+
{
|
|
38946
|
+
resource: "registry.repositories",
|
|
38947
|
+
method: "create",
|
|
38948
|
+
summary: "Create repository",
|
|
38949
|
+
description: "新建一个库来分类存放包。name 是库的唯一标识,小写字母、数字和连字符,最多 63 个字符,且不能和已有的库重名;display_name 和 description 是给人看的。每个组织本来就有一个默认库,需要新分类时才建;一个库非空时不能删除,所以不要用库来临时隔离一次上传。",
|
|
38950
|
+
http: "POST",
|
|
38951
|
+
path: "/registry/v1/repositories",
|
|
38952
|
+
streaming: "no",
|
|
38953
|
+
pagination: false,
|
|
38954
|
+
pathParams: [],
|
|
38955
|
+
query: [],
|
|
38956
|
+
body: {
|
|
38957
|
+
required: true,
|
|
38958
|
+
fields: [
|
|
38959
|
+
{
|
|
38960
|
+
name: "name",
|
|
38961
|
+
type: "string",
|
|
38962
|
+
required: true,
|
|
38963
|
+
description: "新库的唯一标识,小写字母、数字和连字符,最多 63 个字符,且在这个组织里未被使用;不能只有一个连字符结尾。"
|
|
38964
|
+
},
|
|
38965
|
+
{
|
|
38966
|
+
name: "display_name",
|
|
38967
|
+
type: "string",
|
|
38968
|
+
required: false,
|
|
38969
|
+
description: "给人看的库名;省略时后续显示 name。"
|
|
38970
|
+
},
|
|
38971
|
+
{
|
|
38972
|
+
name: "description",
|
|
38973
|
+
type: "string",
|
|
38974
|
+
required: false,
|
|
38975
|
+
description: "库的说明;省略时不写。"
|
|
38976
|
+
}
|
|
38977
|
+
]
|
|
38978
|
+
}
|
|
38979
|
+
},
|
|
38980
|
+
{
|
|
38981
|
+
resource: "registry.repositories",
|
|
38982
|
+
method: "delete",
|
|
38983
|
+
summary: "Delete repository",
|
|
38984
|
+
description: "删一个空的库。默认库不能删(FAILED_PRECONDITION);库里还有包时也不能删,先把包删掉或改用别的库。删除请求重发会 404,所以删除前先读一次确认。",
|
|
38985
|
+
http: "DELETE",
|
|
38986
|
+
path: "/registry/v1/repositories/{repository_id}",
|
|
38987
|
+
streaming: "no",
|
|
38988
|
+
pagination: false,
|
|
38989
|
+
pathParams: [
|
|
38990
|
+
{
|
|
38991
|
+
name: "repository_id",
|
|
38992
|
+
sdkName: "repository_id",
|
|
38993
|
+
description: "库的标识,来自 repositories.list 或 repositories.create 返回的 id;不要传库的 name 或显示名。"
|
|
38994
|
+
}
|
|
38995
|
+
],
|
|
38996
|
+
query: []
|
|
38997
|
+
},
|
|
38998
|
+
{
|
|
38999
|
+
resource: "registry.repositories",
|
|
39000
|
+
method: "retrieve",
|
|
39001
|
+
summary: "Retrieve repository",
|
|
39002
|
+
description: "读一个库的名称、说明、包数量和默认标记。repository_id 来自 repositories.list 或 repositories.create;另一个组织的库或不存在的库一律 404,不区分两者。",
|
|
39003
|
+
http: "GET",
|
|
39004
|
+
path: "/registry/v1/repositories/{repository_id}",
|
|
39005
|
+
streaming: "no",
|
|
39006
|
+
pagination: false,
|
|
39007
|
+
pathParams: [
|
|
39008
|
+
{
|
|
39009
|
+
name: "repository_id",
|
|
39010
|
+
sdkName: "repository_id",
|
|
39011
|
+
description: "库的标识,来自 repositories.list 或 repositories.create 返回的 id;不要传库的 name 或显示名。"
|
|
39012
|
+
}
|
|
39013
|
+
],
|
|
39014
|
+
query: []
|
|
39015
|
+
},
|
|
39016
|
+
{
|
|
39017
|
+
resource: "registry.repositories",
|
|
39018
|
+
method: "update",
|
|
39019
|
+
summary: "Update repository",
|
|
39020
|
+
description: "改库的 display_name 或 description。只送要改的字段,省略的保持原值;name 建库之后不能改,它标识库。一个字段都不送会 400。",
|
|
39021
|
+
http: "PATCH",
|
|
39022
|
+
path: "/registry/v1/repositories/{repository_id}",
|
|
39023
|
+
streaming: "no",
|
|
39024
|
+
pagination: false,
|
|
39025
|
+
pathParams: [
|
|
39026
|
+
{
|
|
39027
|
+
name: "repository_id",
|
|
39028
|
+
sdkName: "repository_id",
|
|
39029
|
+
description: "库的标识,来自 repositories.list 或 repositories.create 返回的 id;不要传库的 name 或显示名。"
|
|
39030
|
+
}
|
|
39031
|
+
],
|
|
39032
|
+
query: [],
|
|
39033
|
+
body: {
|
|
39034
|
+
required: true,
|
|
39035
|
+
fields: [
|
|
39036
|
+
{
|
|
39037
|
+
name: "display_name",
|
|
39038
|
+
type: "string",
|
|
39039
|
+
required: false,
|
|
39040
|
+
description: "新的显示名;显式传 null 会清空它。"
|
|
39041
|
+
},
|
|
39042
|
+
{
|
|
39043
|
+
name: "description",
|
|
39044
|
+
type: "string",
|
|
39045
|
+
required: false,
|
|
39046
|
+
description: "新的说明;显式传 null 会清空它。"
|
|
39047
|
+
}
|
|
39048
|
+
]
|
|
39049
|
+
}
|
|
39050
|
+
},
|
|
39051
|
+
{
|
|
39052
|
+
resource: "registry.repositories.packages",
|
|
39053
|
+
method: "list",
|
|
39054
|
+
summary: "List packages",
|
|
39055
|
+
description: "列出一个库里的包,可按种类筛、按名字搜、按最近更新或下载量排序。kind=skill 只看技能,kind=plugin 只看插件,省略则两类都返回。q 在 name、title 和 description 上做子串匹配。sort 默认 updated;downloads 按累计下载量降序,用来找这个库最常用的资源。",
|
|
39056
|
+
http: "GET",
|
|
39057
|
+
path: "/registry/v1/repositories/{repository_id}/packages",
|
|
39058
|
+
streaming: "no",
|
|
39059
|
+
pagination: true,
|
|
39060
|
+
pathParams: [
|
|
39061
|
+
{
|
|
39062
|
+
name: "repository_id",
|
|
39063
|
+
sdkName: "repository_id",
|
|
39064
|
+
description: "库的标识,来自 repositories.list 或 repositories.create 返回的 id;不要传库的 name 或显示名。"
|
|
39065
|
+
}
|
|
39066
|
+
],
|
|
39067
|
+
query: [
|
|
39068
|
+
{
|
|
39069
|
+
name: "kind",
|
|
39070
|
+
type: "string",
|
|
39071
|
+
enum: [
|
|
39072
|
+
"skill",
|
|
39073
|
+
"plugin"
|
|
39074
|
+
],
|
|
39075
|
+
required: false,
|
|
39076
|
+
description: "只看某一类包;省略时技能和插件都返回。"
|
|
39077
|
+
},
|
|
39078
|
+
{
|
|
39079
|
+
name: "q",
|
|
39080
|
+
type: "string",
|
|
39081
|
+
required: false,
|
|
39082
|
+
description: "按子串搜索包,匹配 name、title 和 description;省略时不过滤。不区分大小写。"
|
|
39083
|
+
},
|
|
39084
|
+
{
|
|
39085
|
+
name: "sort",
|
|
39086
|
+
type: "string",
|
|
39087
|
+
enum: [
|
|
39088
|
+
"updated",
|
|
39089
|
+
"downloads"
|
|
39090
|
+
],
|
|
39091
|
+
required: false,
|
|
39092
|
+
description: "结果排序方式;省略时按 updated。"
|
|
39093
|
+
},
|
|
39094
|
+
{
|
|
39095
|
+
name: "page_size",
|
|
39096
|
+
type: "integer",
|
|
39097
|
+
required: false,
|
|
39098
|
+
description: "每页返回多少条,1 到 100;省略时默认 20。超过 100 会被截到 100。"
|
|
39099
|
+
},
|
|
39100
|
+
{
|
|
39101
|
+
name: "cursor",
|
|
39102
|
+
type: "string",
|
|
39103
|
+
required: false,
|
|
39104
|
+
description: "上一页返回的 next_cursor,用来取下一页;第一页省略它,next_cursor 为 null 时停止翻页。"
|
|
39105
|
+
}
|
|
39106
|
+
]
|
|
39107
|
+
},
|
|
39108
|
+
{
|
|
39109
|
+
resource: "registry.repositories.packages",
|
|
39110
|
+
method: "create",
|
|
39111
|
+
summary: "Publish a package",
|
|
39112
|
+
description: "把一个新包发布进这个库,一次调用建立包并上传它的第一个版本。发布内容是 multipart:version 必填,archive 给一个 zip,或者 files 给一组文件(每个文件的 filename 是相对上传根的路径,例如 pdf/SKILL.md)。单个顶层目录会被剥掉。种类按根上有什么判:有 SKILL.md 就是 skill,有 .claude-plugin/plugin.json 就是 plugin;两者都没有、或都有,会被拒。名字从 SKILL.md 或 plugin.json 里读,不从路径或 query 猜。限额:上传 ≤25 MiB,解压后 ≤50 MiB,≤1000 个文件。版本必须是 semver 且严格递增;第一个版本可以是任意合法 semver,之后每个新版本都要比已发布的最高版本高。把已有智能体的技能搬过来时,先用 GET /agent/v1/skills/{id}/versions/{v}/content 导出 zip,再在这里作为 archive 发布。",
|
|
39113
|
+
http: "POST",
|
|
39114
|
+
path: "/registry/v1/repositories/{repository_id}/packages",
|
|
39115
|
+
streaming: "no",
|
|
39116
|
+
pagination: false,
|
|
39117
|
+
multipart: true,
|
|
39118
|
+
pathParams: [
|
|
39119
|
+
{
|
|
39120
|
+
name: "repository_id",
|
|
39121
|
+
sdkName: "repository_id",
|
|
39122
|
+
description: "库的标识,来自 repositories.list 或 repositories.create 返回的 id;不要传库的 name 或显示名。"
|
|
39123
|
+
}
|
|
39124
|
+
],
|
|
39125
|
+
query: [],
|
|
39126
|
+
body: {
|
|
39127
|
+
required: true,
|
|
39128
|
+
fields: [
|
|
39129
|
+
{
|
|
39130
|
+
name: "version",
|
|
39131
|
+
type: "string",
|
|
39132
|
+
required: true,
|
|
39133
|
+
description: "要发布的版本号,完整 semver,例如 1.2.0;每个包内必须严格递增,撤回的版本也占号。"
|
|
39134
|
+
},
|
|
39135
|
+
{
|
|
39136
|
+
name: "archive",
|
|
39137
|
+
type: "string",
|
|
39138
|
+
required: false,
|
|
39139
|
+
description: "一个 zip 文件,内含包的内容;与 files 二选一。单个顶层目录会被剥掉。"
|
|
39140
|
+
},
|
|
39141
|
+
{
|
|
39142
|
+
name: "files",
|
|
39143
|
+
type: "array",
|
|
39144
|
+
itemType: "string",
|
|
39145
|
+
required: false,
|
|
39146
|
+
description: "直接上传的一组文件,每个 part 的 filename 是相对路径;与 archive 二选一。"
|
|
39147
|
+
},
|
|
39148
|
+
{
|
|
39149
|
+
name: "title",
|
|
39150
|
+
type: "string",
|
|
39151
|
+
required: false,
|
|
39152
|
+
description: "给人看的标题;省略时从包内容里取。"
|
|
39153
|
+
},
|
|
39154
|
+
{
|
|
39155
|
+
name: "description",
|
|
39156
|
+
type: "string",
|
|
39157
|
+
required: false,
|
|
39158
|
+
description: "包说明;省略时从包内容里取。"
|
|
39159
|
+
},
|
|
39160
|
+
{
|
|
39161
|
+
name: "tags",
|
|
39162
|
+
type: "string",
|
|
39163
|
+
required: false,
|
|
39164
|
+
description: "逗号分隔的标签,例如 review,quality;省略时没有标签。"
|
|
39165
|
+
}
|
|
39166
|
+
]
|
|
39167
|
+
}
|
|
39168
|
+
},
|
|
38498
39169
|
{
|
|
38499
39170
|
resource: "sandbox.events.sandboxes",
|
|
38500
39171
|
method: "retrieve",
|
|
@@ -40641,16 +41312,18 @@ for more details.`
|
|
|
40641
41312
|
type: "string",
|
|
40642
41313
|
enum: [
|
|
40643
41314
|
"file",
|
|
40644
|
-
"artifact"
|
|
41315
|
+
"artifact",
|
|
41316
|
+
"canvas",
|
|
41317
|
+
"media_asset"
|
|
40645
41318
|
],
|
|
40646
41319
|
required: false,
|
|
40647
|
-
description: "Only shares of this object type; file
|
|
41320
|
+
description: "Only shares of this object type; file, canvas and media_asset create today."
|
|
40648
41321
|
},
|
|
40649
41322
|
{
|
|
40650
41323
|
name: "resource_id",
|
|
40651
41324
|
type: "string",
|
|
40652
41325
|
required: false,
|
|
40653
|
-
description: "Only shares of the object with this id, for example a file id from the File API; combine with resource_type."
|
|
41326
|
+
description: "Only shares of the object with this id, for example a file id from the File API or a media asset's library_id/asset_id; combine with resource_type."
|
|
40654
41327
|
},
|
|
40655
41328
|
{
|
|
40656
41329
|
name: "status",
|
|
@@ -47222,6 +47895,19 @@ var getAgentConsolidation = (options) => (options.client ?? client).get({
|
|
|
47222
47895
|
url: "/agent/v1/agents/{agent_id}/consolidations/{consolidation_id}",
|
|
47223
47896
|
...options
|
|
47224
47897
|
});
|
|
47898
|
+
var listAgentInboxLetters = (options) => (options.client ?? client).get({
|
|
47899
|
+
security: [{
|
|
47900
|
+
key: "BearerAuth",
|
|
47901
|
+
scheme: "bearer",
|
|
47902
|
+
type: "http"
|
|
47903
|
+
}, {
|
|
47904
|
+
key: "ApiKeyAuth",
|
|
47905
|
+
name: "X-API-Key",
|
|
47906
|
+
type: "apiKey"
|
|
47907
|
+
}],
|
|
47908
|
+
url: "/agent/v1/agents/{agent_id}/inbox/letters",
|
|
47909
|
+
...options
|
|
47910
|
+
});
|
|
47225
47911
|
var applyAgentVersion = (options) => (options.client ?? client).post({
|
|
47226
47912
|
security: [{
|
|
47227
47913
|
key: "BearerAuth",
|
|
@@ -54828,6 +55514,28 @@ var mediaAlignAsset = (options) => (options.client ?? client).post({
|
|
|
54828
55514
|
...options.headers
|
|
54829
55515
|
}
|
|
54830
55516
|
});
|
|
55517
|
+
var mediaGetHlsRenditions = (options) => (options.client ?? client).get({
|
|
55518
|
+
security: [{
|
|
55519
|
+
key: "media-BearerAuth",
|
|
55520
|
+
scheme: "bearer",
|
|
55521
|
+
type: "http"
|
|
55522
|
+
}],
|
|
55523
|
+
url: "/media/v1/libraries/{library_id}/assets/{asset_id}/hls",
|
|
55524
|
+
...options
|
|
55525
|
+
});
|
|
55526
|
+
var mediaRequestHlsRenditions = (options) => (options.client ?? client).post({
|
|
55527
|
+
security: [{
|
|
55528
|
+
key: "media-BearerAuth",
|
|
55529
|
+
scheme: "bearer",
|
|
55530
|
+
type: "http"
|
|
55531
|
+
}],
|
|
55532
|
+
url: "/media/v1/libraries/{library_id}/assets/{asset_id}/hls",
|
|
55533
|
+
...options,
|
|
55534
|
+
headers: {
|
|
55535
|
+
"Content-Type": "application/json",
|
|
55536
|
+
...options.headers
|
|
55537
|
+
}
|
|
55538
|
+
});
|
|
54831
55539
|
var ontologyListTypes = (options) => (options?.client ?? client).get({
|
|
54832
55540
|
security: [{
|
|
54833
55541
|
key: "ontology-bearerAuth",
|
|
@@ -54995,6 +55703,194 @@ var ontologySearch = (options) => (options.client ?? client).post({
|
|
|
54995
55703
|
...options.headers
|
|
54996
55704
|
}
|
|
54997
55705
|
});
|
|
55706
|
+
var registryRepositoriesList = (options) => (options?.client ?? client).get({
|
|
55707
|
+
security: [{
|
|
55708
|
+
key: "registry-bearerAuth",
|
|
55709
|
+
scheme: "bearer",
|
|
55710
|
+
type: "http"
|
|
55711
|
+
}],
|
|
55712
|
+
url: "/registry/v1/repositories",
|
|
55713
|
+
...options
|
|
55714
|
+
});
|
|
55715
|
+
var registryRepositoriesCreate = (options) => (options.client ?? client).post({
|
|
55716
|
+
security: [{
|
|
55717
|
+
key: "registry-bearerAuth",
|
|
55718
|
+
scheme: "bearer",
|
|
55719
|
+
type: "http"
|
|
55720
|
+
}],
|
|
55721
|
+
url: "/registry/v1/repositories",
|
|
55722
|
+
...options,
|
|
55723
|
+
headers: {
|
|
55724
|
+
"Content-Type": "application/json",
|
|
55725
|
+
...options.headers
|
|
55726
|
+
}
|
|
55727
|
+
});
|
|
55728
|
+
var registryRepositoriesDelete = (options) => (options.client ?? client).delete({
|
|
55729
|
+
security: [{
|
|
55730
|
+
key: "registry-bearerAuth",
|
|
55731
|
+
scheme: "bearer",
|
|
55732
|
+
type: "http"
|
|
55733
|
+
}],
|
|
55734
|
+
url: "/registry/v1/repositories/{repository_id}",
|
|
55735
|
+
...options
|
|
55736
|
+
});
|
|
55737
|
+
var registryRepositoriesRetrieve = (options) => (options.client ?? client).get({
|
|
55738
|
+
security: [{
|
|
55739
|
+
key: "registry-bearerAuth",
|
|
55740
|
+
scheme: "bearer",
|
|
55741
|
+
type: "http"
|
|
55742
|
+
}],
|
|
55743
|
+
url: "/registry/v1/repositories/{repository_id}",
|
|
55744
|
+
...options
|
|
55745
|
+
});
|
|
55746
|
+
var registryRepositoriesUpdate = (options) => (options.client ?? client).patch({
|
|
55747
|
+
security: [{
|
|
55748
|
+
key: "registry-bearerAuth",
|
|
55749
|
+
scheme: "bearer",
|
|
55750
|
+
type: "http"
|
|
55751
|
+
}],
|
|
55752
|
+
url: "/registry/v1/repositories/{repository_id}",
|
|
55753
|
+
...options,
|
|
55754
|
+
headers: {
|
|
55755
|
+
"Content-Type": "application/json",
|
|
55756
|
+
...options.headers
|
|
55757
|
+
}
|
|
55758
|
+
});
|
|
55759
|
+
var registryRepositoriesPackagesList = (options) => (options.client ?? client).get({
|
|
55760
|
+
security: [{
|
|
55761
|
+
key: "registry-bearerAuth",
|
|
55762
|
+
scheme: "bearer",
|
|
55763
|
+
type: "http"
|
|
55764
|
+
}],
|
|
55765
|
+
url: "/registry/v1/repositories/{repository_id}/packages",
|
|
55766
|
+
...options
|
|
55767
|
+
});
|
|
55768
|
+
var registryRepositoriesPackagesCreate = (options) => (options.client ?? client).post({
|
|
55769
|
+
...formDataBodySerializer,
|
|
55770
|
+
security: [{
|
|
55771
|
+
key: "registry-bearerAuth",
|
|
55772
|
+
scheme: "bearer",
|
|
55773
|
+
type: "http"
|
|
55774
|
+
}],
|
|
55775
|
+
url: "/registry/v1/repositories/{repository_id}/packages",
|
|
55776
|
+
...options,
|
|
55777
|
+
headers: {
|
|
55778
|
+
"Content-Type": null,
|
|
55779
|
+
...options.headers
|
|
55780
|
+
}
|
|
55781
|
+
});
|
|
55782
|
+
var registryPackagesRetrieve = (options) => (options.client ?? client).get({
|
|
55783
|
+
security: [{
|
|
55784
|
+
key: "registry-bearerAuth",
|
|
55785
|
+
scheme: "bearer",
|
|
55786
|
+
type: "http"
|
|
55787
|
+
}],
|
|
55788
|
+
url: "/registry/v1/packages/{package_id}",
|
|
55789
|
+
...options
|
|
55790
|
+
});
|
|
55791
|
+
var registryPackagesVersionsList = (options) => (options.client ?? client).get({
|
|
55792
|
+
security: [{
|
|
55793
|
+
key: "registry-bearerAuth",
|
|
55794
|
+
scheme: "bearer",
|
|
55795
|
+
type: "http"
|
|
55796
|
+
}],
|
|
55797
|
+
url: "/registry/v1/packages/{package_id}/versions",
|
|
55798
|
+
...options
|
|
55799
|
+
});
|
|
55800
|
+
var registryPackagesVersionsCreate = (options) => (options.client ?? client).post({
|
|
55801
|
+
...formDataBodySerializer,
|
|
55802
|
+
security: [{
|
|
55803
|
+
key: "registry-bearerAuth",
|
|
55804
|
+
scheme: "bearer",
|
|
55805
|
+
type: "http"
|
|
55806
|
+
}],
|
|
55807
|
+
url: "/registry/v1/packages/{package_id}/versions",
|
|
55808
|
+
...options,
|
|
55809
|
+
headers: {
|
|
55810
|
+
"Content-Type": null,
|
|
55811
|
+
...options.headers
|
|
55812
|
+
}
|
|
55813
|
+
});
|
|
55814
|
+
var registryPackagesVersionsContents = (options) => (options.client ?? client).get({
|
|
55815
|
+
security: [{
|
|
55816
|
+
key: "registry-bearerAuth",
|
|
55817
|
+
scheme: "bearer",
|
|
55818
|
+
type: "http"
|
|
55819
|
+
}],
|
|
55820
|
+
url: "/registry/v1/packages/{package_id}/versions/{version}/contents",
|
|
55821
|
+
...options
|
|
55822
|
+
});
|
|
55823
|
+
var registryPackagesVersionsFilesRetrieve = (options) => (options.client ?? client).get({
|
|
55824
|
+
security: [{
|
|
55825
|
+
key: "registry-bearerAuth",
|
|
55826
|
+
scheme: "bearer",
|
|
55827
|
+
type: "http"
|
|
55828
|
+
}],
|
|
55829
|
+
url: "/registry/v1/packages/{package_id}/versions/{version}/files/{path}",
|
|
55830
|
+
...options
|
|
55831
|
+
});
|
|
55832
|
+
var registryPackagesVersionsArchive = (options) => (options.client ?? client).get({
|
|
55833
|
+
security: [{
|
|
55834
|
+
key: "registry-bearerAuth",
|
|
55835
|
+
scheme: "bearer",
|
|
55836
|
+
type: "http"
|
|
55837
|
+
}],
|
|
55838
|
+
url: "/registry/v1/packages/{package_id}/versions/{version}/archive",
|
|
55839
|
+
...options
|
|
55840
|
+
});
|
|
55841
|
+
var registryPackagesVersionsWithdraw = (options) => (options.client ?? client).post({
|
|
55842
|
+
security: [{
|
|
55843
|
+
key: "registry-bearerAuth",
|
|
55844
|
+
scheme: "bearer",
|
|
55845
|
+
type: "http"
|
|
55846
|
+
}],
|
|
55847
|
+
url: "/registry/v1/packages/{package_id}/versions/{version}:withdraw",
|
|
55848
|
+
...options
|
|
55849
|
+
});
|
|
55850
|
+
var registryPackagesInstallationsList = (options) => (options.client ?? client).get({
|
|
55851
|
+
security: [{
|
|
55852
|
+
key: "registry-bearerAuth",
|
|
55853
|
+
scheme: "bearer",
|
|
55854
|
+
type: "http"
|
|
55855
|
+
}],
|
|
55856
|
+
url: "/registry/v1/packages/{package_id}/installations",
|
|
55857
|
+
...options
|
|
55858
|
+
});
|
|
55859
|
+
var registryPackagesInstallationsCreate = (options) => (options.client ?? client).post({
|
|
55860
|
+
security: [{
|
|
55861
|
+
key: "registry-bearerAuth",
|
|
55862
|
+
scheme: "bearer",
|
|
55863
|
+
type: "http"
|
|
55864
|
+
}],
|
|
55865
|
+
url: "/registry/v1/packages/{package_id}/installations",
|
|
55866
|
+
...options,
|
|
55867
|
+
headers: {
|
|
55868
|
+
"Content-Type": "application/json",
|
|
55869
|
+
...options.headers
|
|
55870
|
+
}
|
|
55871
|
+
});
|
|
55872
|
+
var registryInstallationsUpdate = (options) => (options.client ?? client).post({
|
|
55873
|
+
security: [{
|
|
55874
|
+
key: "registry-bearerAuth",
|
|
55875
|
+
scheme: "bearer",
|
|
55876
|
+
type: "http"
|
|
55877
|
+
}],
|
|
55878
|
+
url: "/registry/v1/installations/{installation_id}:update",
|
|
55879
|
+
...options,
|
|
55880
|
+
headers: {
|
|
55881
|
+
"Content-Type": "application/json",
|
|
55882
|
+
...options.headers
|
|
55883
|
+
}
|
|
55884
|
+
});
|
|
55885
|
+
var registryInstallationsDelete = (options) => (options.client ?? client).delete({
|
|
55886
|
+
security: [{
|
|
55887
|
+
key: "registry-bearerAuth",
|
|
55888
|
+
scheme: "bearer",
|
|
55889
|
+
type: "http"
|
|
55890
|
+
}],
|
|
55891
|
+
url: "/registry/v1/installations/{installation_id}",
|
|
55892
|
+
...options
|
|
55893
|
+
});
|
|
54998
55894
|
var getSandboxV1Sandboxes = (options) => (options?.client ?? client).get({
|
|
54999
55895
|
querySerializer: { parameters: { state: { array: { explode: false } } } },
|
|
55000
55896
|
security: [
|
|
@@ -58036,6 +58932,11 @@ function createAgent(transport) {
|
|
|
58036
58932
|
send: bind(transport, sendAgentEvents),
|
|
58037
58933
|
stream: bindStream(transport, streamAgentEvents)
|
|
58038
58934
|
},
|
|
58935
|
+
inbox: {
|
|
58936
|
+
letters: {
|
|
58937
|
+
list: bind(transport, listAgentInboxLetters)
|
|
58938
|
+
}
|
|
58939
|
+
},
|
|
58039
58940
|
list: bind(transport, agentsList),
|
|
58040
58941
|
retrieve: bind(transport, agentsRetrieve),
|
|
58041
58942
|
retrieveAppearance: bind(transport, getAgentAppearance),
|
|
@@ -58853,6 +59754,10 @@ function createMedia(transport) {
|
|
|
58853
59754
|
frames: {
|
|
58854
59755
|
create: bind(transport, mediaCreateFrameUrls)
|
|
58855
59756
|
},
|
|
59757
|
+
hls: {
|
|
59758
|
+
create: bind(transport, mediaRequestHlsRenditions),
|
|
59759
|
+
list: bind(transport, mediaGetHlsRenditions)
|
|
59760
|
+
},
|
|
58856
59761
|
import: {
|
|
58857
59762
|
create: bind(transport, mediaImportAsset)
|
|
58858
59763
|
},
|
|
@@ -59190,6 +60095,44 @@ function createOrganization(transport) {
|
|
|
59190
60095
|
}
|
|
59191
60096
|
};
|
|
59192
60097
|
}
|
|
60098
|
+
function createRegistry(transport) {
|
|
60099
|
+
return {
|
|
60100
|
+
installations: {
|
|
60101
|
+
delete: bind(transport, registryInstallationsDelete),
|
|
60102
|
+
update: bind(transport, registryInstallationsUpdate)
|
|
60103
|
+
},
|
|
60104
|
+
packages: {
|
|
60105
|
+
installations: {
|
|
60106
|
+
create: bind(transport, registryPackagesInstallationsCreate),
|
|
60107
|
+
list: bind(transport, registryPackagesInstallationsList)
|
|
60108
|
+
},
|
|
60109
|
+
retrieve: bind(transport, registryPackagesRetrieve),
|
|
60110
|
+
versions: {
|
|
60111
|
+
contents: {
|
|
60112
|
+
list: bind(transport, registryPackagesVersionsContents)
|
|
60113
|
+
},
|
|
60114
|
+
create: bind(transport, (options) => registryPackagesVersionsCreate({ ...options, bodySerializer: multipartBodySerializer, headers: { "Content-Type": null, ...options.headers } })),
|
|
60115
|
+
files: {
|
|
60116
|
+
retrieve: bind(transport, registryPackagesVersionsFilesRetrieve)
|
|
60117
|
+
},
|
|
60118
|
+
list: bindPage(transport, registryPackagesVersionsList),
|
|
60119
|
+
retrieveArchive: bind(transport, registryPackagesVersionsArchive),
|
|
60120
|
+
withdraw: bind(transport, registryPackagesVersionsWithdraw)
|
|
60121
|
+
}
|
|
60122
|
+
},
|
|
60123
|
+
repositories: {
|
|
60124
|
+
create: bind(transport, registryRepositoriesCreate),
|
|
60125
|
+
delete: bind(transport, registryRepositoriesDelete),
|
|
60126
|
+
list: bindPage(transport, registryRepositoriesList),
|
|
60127
|
+
packages: {
|
|
60128
|
+
create: bind(transport, (options) => registryRepositoriesPackagesCreate({ ...options, bodySerializer: multipartBodySerializer, headers: { "Content-Type": null, ...options.headers } })),
|
|
60129
|
+
list: bindPage(transport, registryRepositoriesPackagesList)
|
|
60130
|
+
},
|
|
60131
|
+
retrieve: bind(transport, registryRepositoriesRetrieve),
|
|
60132
|
+
update: bind(transport, registryRepositoriesUpdate)
|
|
60133
|
+
}
|
|
60134
|
+
};
|
|
60135
|
+
}
|
|
59193
60136
|
function createSandbox(transport) {
|
|
59194
60137
|
return {
|
|
59195
60138
|
events: {
|
|
@@ -59566,6 +60509,7 @@ var resourceFactories = {
|
|
|
59566
60509
|
model: createModel,
|
|
59567
60510
|
ontology: createOntology,
|
|
59568
60511
|
organization: createOrganization,
|
|
60512
|
+
registry: createRegistry,
|
|
59569
60513
|
sandbox: createSandbox,
|
|
59570
60514
|
search: createSearch,
|
|
59571
60515
|
share: createShare,
|
|
@@ -60961,6 +61905,14 @@ var multipartBinaryFields = {
|
|
|
60961
61905
|
"POST /model/v1/images/edits": [],
|
|
60962
61906
|
"POST /model/v1/videos": [
|
|
60963
61907
|
"input_reference"
|
|
61908
|
+
],
|
|
61909
|
+
"POST /registry/v1/packages/{package_id}/versions": [
|
|
61910
|
+
"archive",
|
|
61911
|
+
"files"
|
|
61912
|
+
],
|
|
61913
|
+
"POST /registry/v1/repositories/{repository_id}/packages": [
|
|
61914
|
+
"archive",
|
|
61915
|
+
"files"
|
|
60964
61916
|
]
|
|
60965
61917
|
};
|
|
60966
61918
|
|
|
@@ -61386,7 +62338,7 @@ function help(commands, prefix, command) {
|
|
|
61386
62338
|
...[...operationOptions(command.op), ...bodyDataOption(command.op), ...globalOptions].map((s) => ` ${describeOption(s, s.required && fieldRequired(command.op, s, s.location ?? "query"))}`),
|
|
61387
62339
|
...command.op.body?.fields.filter((f) => !operationOptions(command.op).some((s) => s.location === "body" && s.field === f) && (f.type === "object" || f.type === "array" && !["string", "number", "integer", "boolean"].includes(f.itemType ?? ""))).map((f) => ` --data: ${f.name} (${f.type}${f.required ? ", required" : ""})`) ?? [],
|
|
61388
62340
|
" -h is an alias of --help",
|
|
61389
|
-
"PRAXIS_ENV=develop
|
|
62341
|
+
"PRAXIS_ENV=production|develop (default: production; develop must be named); no --env option.",
|
|
61390
62342
|
"",
|
|
61391
62343
|
"Examples:",
|
|
61392
62344
|
` ${example(command)}`
|
|
@@ -61398,7 +62350,7 @@ function help(commands, prefix, command) {
|
|
|
61398
62350
|
"Global options:",
|
|
61399
62351
|
...globalOptions.map((s) => ` ${describeOption(s)}`),
|
|
61400
62352
|
" -h is an alias of --help",
|
|
61401
|
-
"PRAXIS_ENV=develop
|
|
62353
|
+
"PRAXIS_ENV=production|develop (default: production; develop must be named); no --env option.",
|
|
61402
62354
|
""
|
|
61403
62355
|
];
|
|
61404
62356
|
const sample = matching.find((c) => c.words.at(-1) === "list") ?? matching[0];
|
|
@@ -61886,6 +62838,41 @@ var workflows = [
|
|
|
61886
62838
|
platform: "praxis api devops project change create — the platform creates and names a Change; the CLI only lands its branch (ADR-125 §5).",
|
|
61887
62839
|
docs: "https://docs.deepraxis.com/docs/cli"
|
|
61888
62840
|
},
|
|
62841
|
+
{
|
|
62842
|
+
words: ["agent", "events", "wait"],
|
|
62843
|
+
usage: "agent events wait [--timeout <seconds>]",
|
|
62844
|
+
summary: "Wait until a new letter arrives for your assume agent (PRAXIS_ASSUME_AGENT, default R1M9TQ2X), print who wrote and how to read it, and exit 0. It first checks the waiting letters once, so mail that arrived while nothing waited is reported at once; then it follows the agent's event stream, reconnecting with backoff. Nothing is marked read. Run it as a background task in Claude Code: its exit wakes the idle session; read the mail with praxis_assume_inbox and start it again.",
|
|
62845
|
+
example: "PRAXIS_ASSUME_AGENT=R1M9TQ2X praxis agent events wait",
|
|
62846
|
+
network: "online"
|
|
62847
|
+
},
|
|
62848
|
+
{
|
|
62849
|
+
words: ["agent", "memory"],
|
|
62850
|
+
usage: "agent memory [--hook SessionStart|UserPromptSubmit]",
|
|
62851
|
+
summary: "Print your assume agent's memory as it stands now (PRAXIS_ASSUME_AGENT): who it is, its post, manager, duties and the charters it works under, drawn from its organization. With --hook it reads the Claude Code hook input on stdin and prints the hook's JSON: the whole memory at SessionStart, only what is new since that session last read it at UserPromptSubmit; it never fails the hook.",
|
|
62852
|
+
example: "praxis agent memory",
|
|
62853
|
+
network: "online"
|
|
62854
|
+
},
|
|
62855
|
+
{
|
|
62856
|
+
words: ["agent", "recall"],
|
|
62857
|
+
usage: "agent recall [--words <w,w>] [--handles <id,id>]",
|
|
62858
|
+
summary: "Recall from your assume agent's memory: with no flags, what else comes to mind; with words, what was filed under them; with handles, that entry and its original.",
|
|
62859
|
+
example: "praxis agent recall --words 章程,运维部",
|
|
62860
|
+
network: "online"
|
|
62861
|
+
},
|
|
62862
|
+
{
|
|
62863
|
+
words: ["agent", "remember"],
|
|
62864
|
+
usage: "agent remember --text <experience> [--about <id,id>]",
|
|
62865
|
+
summary: "Keep an experience in your assume agent's memory: it is consolidated in the background like a lived conversation, and recall finds it afterwards.",
|
|
62866
|
+
example: 'praxis agent remember --text "Sean 定了副总裁用钩子载入认知"',
|
|
62867
|
+
network: "online"
|
|
62868
|
+
},
|
|
62869
|
+
{
|
|
62870
|
+
words: ["agent", "events", "channel"],
|
|
62871
|
+
usage: "agent events channel",
|
|
62872
|
+
summary: "Run as a Claude Code channel (a stdio MCP server declaring claude/channel, no tools): pushes the waiting letters once, then every new letter and new memory of your assume agent (PRAXIS_ASSUME_AGENT, default R1M9TQ2X) into the running session. Started by the assume-agent plugin, not by hand; stdout carries MCP frames only, logs go to stderr.",
|
|
62873
|
+
example: "claude --dangerously-load-development-channels plugin:assume-agent@deepraxis",
|
|
62874
|
+
network: "online"
|
|
62875
|
+
},
|
|
61889
62876
|
{ words: ["canvas", "import"], usage: "canvas import <file.pen> [--name <name>] [--canvas <cvs_…> --yes] [--frames <id,id>] [--image-root <dir>] [--dry-run]", summary: "Import a Pencil .pen file as a canvas, uploading the images it references first.", example: 'praxis canvas import design.pen --name "Landing page"' },
|
|
61890
62877
|
{ words: ["skill"], usage: "skill [--install <dir>]", summary: "Print the AI skill, or write <dir>/praxis-cli/SKILL.md." },
|
|
61891
62878
|
{
|
|
@@ -61955,7 +62942,7 @@ function workflowHelp(workflow, options) {
|
|
|
61955
62942
|
"Options:",
|
|
61956
62943
|
...[...options, ...globalOptions].map((s) => ` ${describeOption(s)}`),
|
|
61957
62944
|
" -h is an alias of --help",
|
|
61958
|
-
"PRAXIS_ENV=develop
|
|
62945
|
+
"PRAXIS_ENV=production|develop (default: production; develop must be named); no --env option.",
|
|
61959
62946
|
...workflow.requires === "checkout" ? [`Requires: ${CHECKOUT_REQUIREMENT}`] : [],
|
|
61960
62947
|
...workflow.notes?.length ? ["", ...workflow.notes] : [],
|
|
61961
62948
|
...workflow.network ? ["", `Network: ${workflow.network}`] : [],
|
|
@@ -63478,12 +64465,216 @@ function wranglerEdges(nodes) {
|
|
|
63478
64465
|
}
|
|
63479
64466
|
return edges;
|
|
63480
64467
|
}
|
|
64468
|
+
// ../../packages/praxis/deploy-core/src/job-events.ts
|
|
64469
|
+
var DEFAULT_EXPIRE_MINUTES = 60;
|
|
64470
|
+
var DEFAULT_PHASE_ID = "stable";
|
|
64471
|
+
function jobStatesOf(outcome) {
|
|
64472
|
+
switch (outcome.kind) {
|
|
64473
|
+
case "succeeded":
|
|
64474
|
+
return { jobState: "succeeded", jobRunState: "succeeded" };
|
|
64475
|
+
case "failed":
|
|
64476
|
+
return { jobState: "failed", jobRunState: "failed" };
|
|
64477
|
+
case "disabled":
|
|
64478
|
+
return { jobState: "disabled", jobRunState: "unspecified" };
|
|
64479
|
+
case "skipped":
|
|
64480
|
+
return { jobState: "skipped", jobRunState: "unspecified" };
|
|
64481
|
+
}
|
|
64482
|
+
}
|
|
64483
|
+
function formatDeployEvent(event) {
|
|
64484
|
+
return `${JSON.stringify(event)}
|
|
64485
|
+
`;
|
|
64486
|
+
}
|
|
64487
|
+
function expireTimeOf(startedAt, expireMinutes = DEFAULT_EXPIRE_MINUTES) {
|
|
64488
|
+
const start = Date.parse(startedAt);
|
|
64489
|
+
if (Number.isNaN(start))
|
|
64490
|
+
throw new Error(`--events-file needs a parseable start time, got ${JSON.stringify(startedAt)}`);
|
|
64491
|
+
const minutes = Number(expireMinutes);
|
|
64492
|
+
if (!Number.isFinite(minutes) || minutes <= 0)
|
|
64493
|
+
throw new Error(`--expire-minutes must be a positive number, got ${JSON.stringify(expireMinutes)}`);
|
|
64494
|
+
return new Date(start + minutes * 60000).toISOString();
|
|
64495
|
+
}
|
|
64496
|
+
function decidePhaseState(states) {
|
|
64497
|
+
if (states.length === 0)
|
|
64498
|
+
return "unspecified";
|
|
64499
|
+
if (states.some((state) => state === "failed" || state === "aborted"))
|
|
64500
|
+
return "failed";
|
|
64501
|
+
if (states.some((state) => state === "in_progress" || state === "pending"))
|
|
64502
|
+
return "in_progress";
|
|
64503
|
+
const neverRan = states.every((state) => state === "skipped" || state === "disabled");
|
|
64504
|
+
return neverRan ? "skipped" : "succeeded";
|
|
64505
|
+
}
|
|
64506
|
+
function decideRolloutState(jobs, options = {}) {
|
|
64507
|
+
const states = [...jobs.values()];
|
|
64508
|
+
if (states.some((state) => state === "failed" || state === "aborted"))
|
|
64509
|
+
return "failed";
|
|
64510
|
+
const deploy = jobs.get("deploy");
|
|
64511
|
+
if (deploy === undefined || deploy === "pending" || deploy === "in_progress" || deploy === "disabled")
|
|
64512
|
+
return "pending";
|
|
64513
|
+
if (deploy === "skipped" && options.artifactIdentical !== true)
|
|
64514
|
+
return "pending";
|
|
64515
|
+
if (states.every((state) => state === "succeeded" || state === "skipped" || state === "disabled" || state === "ignored")) {
|
|
64516
|
+
return options.artifactIdentical === true ? "skipped" : "succeeded";
|
|
64517
|
+
}
|
|
64518
|
+
return "pending";
|
|
64519
|
+
}
|
|
64520
|
+
function decideFinishedState(rollouts) {
|
|
64521
|
+
if (rollouts.length === 0)
|
|
64522
|
+
return "failed";
|
|
64523
|
+
const count3 = (wanted) => rollouts.filter((state) => wanted.includes(state)).length;
|
|
64524
|
+
const succeeded = count3(["succeeded", "skipped"]);
|
|
64525
|
+
const failed = count3(["failed"]);
|
|
64526
|
+
const waiting = count3(["pending"]);
|
|
64527
|
+
if (failed === 0)
|
|
64528
|
+
return succeeded === rollouts.length ? "succeeded" : "failed";
|
|
64529
|
+
return succeeded > 0 && waiting > 0 ? "halted" : "failed";
|
|
64530
|
+
}
|
|
64531
|
+
// ../../packages/praxis/deploy-core/node_modules/yaml/dist/index.js
|
|
64532
|
+
var composer = require_composer2();
|
|
64533
|
+
var Document = require_Document2();
|
|
64534
|
+
var Schema = require_Schema2();
|
|
64535
|
+
var errors = require_errors2();
|
|
64536
|
+
var Alias = require_Alias2();
|
|
64537
|
+
var identity = require_identity2();
|
|
64538
|
+
var Pair = require_Pair2();
|
|
64539
|
+
var Scalar = require_Scalar2();
|
|
64540
|
+
var YAMLMap = require_YAMLMap2();
|
|
64541
|
+
var YAMLSeq = require_YAMLSeq2();
|
|
64542
|
+
var cst = require_cst2();
|
|
64543
|
+
var lexer = require_lexer2();
|
|
64544
|
+
var lineCounter = require_line_counter2();
|
|
64545
|
+
var parser = require_parser2();
|
|
64546
|
+
var publicApi = require_public_api2();
|
|
64547
|
+
var visit = require_visit2();
|
|
64548
|
+
var $Composer = composer.Composer;
|
|
64549
|
+
var $Document = Document.Document;
|
|
64550
|
+
var $Schema = Schema.Schema;
|
|
64551
|
+
var $YAMLError = errors.YAMLError;
|
|
64552
|
+
var $YAMLParseError = errors.YAMLParseError;
|
|
64553
|
+
var $YAMLWarning = errors.YAMLWarning;
|
|
64554
|
+
var $Alias = Alias.Alias;
|
|
64555
|
+
var $isAlias = identity.isAlias;
|
|
64556
|
+
var $isCollection = identity.isCollection;
|
|
64557
|
+
var $isDocument = identity.isDocument;
|
|
64558
|
+
var $isMap = identity.isMap;
|
|
64559
|
+
var $isNode = identity.isNode;
|
|
64560
|
+
var $isPair = identity.isPair;
|
|
64561
|
+
var $isScalar = identity.isScalar;
|
|
64562
|
+
var $isSeq = identity.isSeq;
|
|
64563
|
+
var $Pair = Pair.Pair;
|
|
64564
|
+
var $Scalar = Scalar.Scalar;
|
|
64565
|
+
var $YAMLMap = YAMLMap.YAMLMap;
|
|
64566
|
+
var $YAMLSeq = YAMLSeq.YAMLSeq;
|
|
64567
|
+
var $Lexer = lexer.Lexer;
|
|
64568
|
+
var $LineCounter = lineCounter.LineCounter;
|
|
64569
|
+
var $Parser = parser.Parser;
|
|
64570
|
+
var $parse = publicApi.parse;
|
|
64571
|
+
var $parseAllDocuments = publicApi.parseAllDocuments;
|
|
64572
|
+
var $parseDocument = publicApi.parseDocument;
|
|
64573
|
+
var $stringify = publicApi.stringify;
|
|
64574
|
+
var $visit = visit.visit;
|
|
64575
|
+
var $visitAsync = visit.visitAsync;
|
|
64576
|
+
|
|
63481
64577
|
// ../../packages/praxis/deploy-core/src/lambda-function.ts
|
|
63482
64578
|
var LAMBDA_FUNCTIONS_ROOT = "services/lambda/functions";
|
|
63483
64579
|
var UPSTREAM = "aliyun-fc";
|
|
63484
|
-
var
|
|
64580
|
+
var PROJECT_FILE = "praxis.yaml";
|
|
64581
|
+
function lambdaFunctionRootOwner(root) {
|
|
64582
|
+
return root.split("/").filter((segment) => segment !== "").slice(0, -1).join("/");
|
|
64583
|
+
}
|
|
64584
|
+
function normalizeRoot(root) {
|
|
64585
|
+
return root.replace(/^\.\//, "").split("/").filter((segment) => segment !== "" && segment !== ".").join("/");
|
|
64586
|
+
}
|
|
64587
|
+
var DEFAULT_ROOTS = [
|
|
64588
|
+
{ root: LAMBDA_FUNCTIONS_ROOT, owner: lambdaFunctionRootOwner(LAMBDA_FUNCTIONS_ROOT) }
|
|
64589
|
+
];
|
|
63485
64590
|
var isText = (value) => typeof value === "string" && value !== "";
|
|
64591
|
+
function lambdaFunctionRootsOf(text) {
|
|
64592
|
+
if (text === null)
|
|
64593
|
+
return { roots: DEFAULT_ROOTS, warnings: [] };
|
|
64594
|
+
let parsed;
|
|
64595
|
+
try {
|
|
64596
|
+
parsed = $parse(text);
|
|
64597
|
+
} catch (cause) {
|
|
64598
|
+
return {
|
|
64599
|
+
roots: DEFAULT_ROOTS,
|
|
64600
|
+
warnings: [`${PROJECT_FILE}: does not parse, so its recipe roots are not read`]
|
|
64601
|
+
};
|
|
64602
|
+
}
|
|
64603
|
+
const declared = readPath(parsed, ["devops", "deploy", "recipes"]);
|
|
64604
|
+
if (declared === undefined)
|
|
64605
|
+
return { roots: DEFAULT_ROOTS, warnings: [] };
|
|
64606
|
+
if (!Array.isArray(declared)) {
|
|
64607
|
+
return {
|
|
64608
|
+
roots: DEFAULT_ROOTS,
|
|
64609
|
+
warnings: [
|
|
64610
|
+
`${PROJECT_FILE}: devops.deploy.recipes is not a list, so its recipe roots are not read`
|
|
64611
|
+
]
|
|
64612
|
+
};
|
|
64613
|
+
}
|
|
64614
|
+
const roots = [];
|
|
64615
|
+
const warnings = [];
|
|
64616
|
+
declared.forEach((entry, index) => {
|
|
64617
|
+
const root = typeof entry === "string" ? entry : typeof entry === "object" && entry !== null ? entry.root : undefined;
|
|
64618
|
+
if (!isText(root)) {
|
|
64619
|
+
warnings.push(`${PROJECT_FILE}: devops.deploy.recipes[${index}] names no root`);
|
|
64620
|
+
return;
|
|
64621
|
+
}
|
|
64622
|
+
const declaredOwner = typeof entry === "object" && entry !== null ? entry.owner : undefined;
|
|
64623
|
+
if (declaredOwner !== undefined && !isText(declaredOwner)) {
|
|
64624
|
+
warnings.push(`${PROJECT_FILE}: devops.deploy.recipes[${index}] names no owner`);
|
|
64625
|
+
return;
|
|
64626
|
+
}
|
|
64627
|
+
const normalized = normalizeRoot(root);
|
|
64628
|
+
if (normalized === "") {
|
|
64629
|
+
warnings.push(`${PROJECT_FILE}: devops.deploy.recipes[${index}] names no root`);
|
|
64630
|
+
return;
|
|
64631
|
+
}
|
|
64632
|
+
if (roots.some((known) => known.root === normalized))
|
|
64633
|
+
return;
|
|
64634
|
+
roots.push({
|
|
64635
|
+
root: normalized,
|
|
64636
|
+
owner: declaredOwner === undefined ? lambdaFunctionRootOwner(normalized) : normalizeRoot(declaredOwner)
|
|
64637
|
+
});
|
|
64638
|
+
});
|
|
64639
|
+
if (roots.length === 0 && warnings.length === 0) {
|
|
64640
|
+
warnings.push(`${PROJECT_FILE}: devops.deploy.recipes declares no root, so no function recipe is a target`);
|
|
64641
|
+
}
|
|
64642
|
+
return { roots, warnings };
|
|
64643
|
+
}
|
|
64644
|
+
function readPath(value, segments) {
|
|
64645
|
+
let current = value;
|
|
64646
|
+
for (const segment of segments) {
|
|
64647
|
+
if (current === null || typeof current !== "object" || Array.isArray(current))
|
|
64648
|
+
return;
|
|
64649
|
+
current = current[segment];
|
|
64650
|
+
}
|
|
64651
|
+
return current;
|
|
64652
|
+
}
|
|
63486
64653
|
var isCount = (value, min, max) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
|
|
64654
|
+
function lambdaFunctionCodeOf(value) {
|
|
64655
|
+
if (value === null || typeof value !== "object" || Array.isArray(value))
|
|
64656
|
+
return null;
|
|
64657
|
+
const declared = value;
|
|
64658
|
+
if (!isText(declared.entry) || !isText(declared.artifact))
|
|
64659
|
+
return null;
|
|
64660
|
+
if (!isText(declared.runtime) || !isText(declared.handler))
|
|
64661
|
+
return null;
|
|
64662
|
+
if (!Array.isArray(declared.layers) || !declared.layers.every(isText))
|
|
64663
|
+
return null;
|
|
64664
|
+
if (!Array.isArray(declared.command) || declared.command.length === 0 || !declared.command.every(isText))
|
|
64665
|
+
return null;
|
|
64666
|
+
if (!isCount(declared.port, 1, 65535))
|
|
64667
|
+
return null;
|
|
64668
|
+
return {
|
|
64669
|
+
entry: declared.entry,
|
|
64670
|
+
artifact: declared.artifact,
|
|
64671
|
+
runtime: declared.runtime,
|
|
64672
|
+
handler: declared.handler,
|
|
64673
|
+
layers: [...declared.layers],
|
|
64674
|
+
command: [...declared.command],
|
|
64675
|
+
port: declared.port
|
|
64676
|
+
};
|
|
64677
|
+
}
|
|
63487
64678
|
function lambdaFunctionOf(text) {
|
|
63488
64679
|
const parsed = text === null ? null : parseJsonc2(text);
|
|
63489
64680
|
if (parsed === null)
|
|
@@ -63502,6 +64693,15 @@ function lambdaFunctionOf(text) {
|
|
|
63502
64693
|
return null;
|
|
63503
64694
|
if (!isCount(parsed.concurrency, 1, 1024))
|
|
63504
64695
|
return null;
|
|
64696
|
+
if (parsed.diskSizeMb !== undefined && !isCount(parsed.diskSizeMb, 512, 10240))
|
|
64697
|
+
return null;
|
|
64698
|
+
let code;
|
|
64699
|
+
if (parsed.code !== undefined) {
|
|
64700
|
+
const declared = lambdaFunctionCodeOf(parsed.code);
|
|
64701
|
+
if (declared === null)
|
|
64702
|
+
return null;
|
|
64703
|
+
code = declared;
|
|
64704
|
+
}
|
|
63505
64705
|
return {
|
|
63506
64706
|
name: parsed.name,
|
|
63507
64707
|
upstream: parsed.upstream,
|
|
@@ -63510,35 +64710,39 @@ function lambdaFunctionOf(text) {
|
|
|
63510
64710
|
cpu: parsed.cpu,
|
|
63511
64711
|
memoryMb: parsed.memoryMb,
|
|
63512
64712
|
timeoutSeconds: parsed.timeoutSeconds,
|
|
63513
|
-
concurrency: parsed.concurrency
|
|
64713
|
+
concurrency: parsed.concurrency,
|
|
64714
|
+
...parsed.diskSizeMb === undefined ? {} : { diskSizeMb: parsed.diskSizeMb },
|
|
64715
|
+
...code === undefined ? {} : { code }
|
|
63514
64716
|
};
|
|
63515
64717
|
}
|
|
63516
|
-
|
|
63517
|
-
return { path: `${LAMBDA_FUNCTIONS_ROOT}/${recipe.name}`, name: `lambda-${recipe.name}` };
|
|
63518
|
-
}
|
|
63519
|
-
function lambdaFunctionOwner(path) {
|
|
63520
|
-
return path.split("/").slice(0, -2).join("/");
|
|
63521
|
-
}
|
|
64718
|
+
var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
63522
64719
|
async function scanRecipes(facts) {
|
|
64720
|
+
const declared = lambdaFunctionRootsOf(await facts.read(PROJECT_FILE));
|
|
63523
64721
|
const found = [];
|
|
63524
|
-
const warnings = [];
|
|
64722
|
+
const warnings = [...declared.warnings];
|
|
64723
|
+
const matchers = declared.roots.map((root) => ({
|
|
64724
|
+
root,
|
|
64725
|
+
pattern: new RegExp(`^${escapeRegExp(root.root)}/([^/]+)/function\\.json$`)
|
|
64726
|
+
}));
|
|
63525
64727
|
for (const path of [...facts.tree].sort()) {
|
|
63526
|
-
const
|
|
63527
|
-
|
|
63528
|
-
|
|
63529
|
-
|
|
63530
|
-
|
|
63531
|
-
|
|
63532
|
-
|
|
63533
|
-
|
|
63534
|
-
|
|
63535
|
-
|
|
63536
|
-
|
|
63537
|
-
|
|
63538
|
-
|
|
63539
|
-
|
|
64728
|
+
for (const { root, pattern } of matchers) {
|
|
64729
|
+
const match = pattern.exec(path);
|
|
64730
|
+
if (match === null)
|
|
64731
|
+
continue;
|
|
64732
|
+
const dir = path.slice(0, -"/function.json".length);
|
|
64733
|
+
const recipe = lambdaFunctionOf(await facts.read(path));
|
|
64734
|
+
if (recipe === null) {
|
|
64735
|
+
warnings.push(`${dir}: function.json is not a recipe`);
|
|
64736
|
+
continue;
|
|
64737
|
+
}
|
|
64738
|
+
if (recipe.upstream !== UPSTREAM)
|
|
64739
|
+
continue;
|
|
64740
|
+
if (recipe.name !== match[1]) {
|
|
64741
|
+
warnings.push(`${dir}: function.json names ${JSON.stringify(recipe.name)}, not the directory name`);
|
|
64742
|
+
continue;
|
|
64743
|
+
}
|
|
64744
|
+
found.push({ recipe, path: dir, root });
|
|
63540
64745
|
}
|
|
63541
|
-
found.push(recipe);
|
|
63542
64746
|
}
|
|
63543
64747
|
return { found, warnings };
|
|
63544
64748
|
}
|
|
@@ -63553,13 +64757,14 @@ function lambdaFunctionProvider(_options = {}) {
|
|
|
63553
64757
|
const scan = await scanRecipes(facts);
|
|
63554
64758
|
const targets = [];
|
|
63555
64759
|
const byOwner = new Map;
|
|
63556
|
-
for (const recipe of scan.found) {
|
|
63557
|
-
const
|
|
64760
|
+
for (const { recipe, path, root } of scan.found) {
|
|
64761
|
+
const name = `lambda-${recipe.name}`;
|
|
63558
64762
|
if (claimed.has(path))
|
|
63559
64763
|
continue;
|
|
63560
64764
|
targets.push({ path, name, destination: "aliyun-fc", production: true, onTrain: true });
|
|
63561
|
-
|
|
63562
|
-
|
|
64765
|
+
if (root.owner === "")
|
|
64766
|
+
continue;
|
|
64767
|
+
byOwner.set(root.owner, [...byOwner.get(root.owner) ?? [], path]);
|
|
63563
64768
|
}
|
|
63564
64769
|
const refined = partial.targets.map((target) => {
|
|
63565
64770
|
const paths = byOwner.get(target.path);
|
|
@@ -63622,52 +64827,6 @@ function environmentsOf(lifecycle) {
|
|
|
63622
64827
|
const named = environments.filter((entry) => typeof entry === "string");
|
|
63623
64828
|
return named.length === 0 ? undefined : named;
|
|
63624
64829
|
}
|
|
63625
|
-
// ../../packages/praxis/deploy-core/node_modules/yaml/dist/index.js
|
|
63626
|
-
var composer = require_composer2();
|
|
63627
|
-
var Document = require_Document2();
|
|
63628
|
-
var Schema = require_Schema2();
|
|
63629
|
-
var errors = require_errors2();
|
|
63630
|
-
var Alias = require_Alias2();
|
|
63631
|
-
var identity = require_identity2();
|
|
63632
|
-
var Pair = require_Pair2();
|
|
63633
|
-
var Scalar = require_Scalar2();
|
|
63634
|
-
var YAMLMap = require_YAMLMap2();
|
|
63635
|
-
var YAMLSeq = require_YAMLSeq2();
|
|
63636
|
-
var cst = require_cst2();
|
|
63637
|
-
var lexer = require_lexer2();
|
|
63638
|
-
var lineCounter = require_line_counter2();
|
|
63639
|
-
var parser = require_parser2();
|
|
63640
|
-
var publicApi = require_public_api2();
|
|
63641
|
-
var visit = require_visit2();
|
|
63642
|
-
var $Composer = composer.Composer;
|
|
63643
|
-
var $Document = Document.Document;
|
|
63644
|
-
var $Schema = Schema.Schema;
|
|
63645
|
-
var $YAMLError = errors.YAMLError;
|
|
63646
|
-
var $YAMLParseError = errors.YAMLParseError;
|
|
63647
|
-
var $YAMLWarning = errors.YAMLWarning;
|
|
63648
|
-
var $Alias = Alias.Alias;
|
|
63649
|
-
var $isAlias = identity.isAlias;
|
|
63650
|
-
var $isCollection = identity.isCollection;
|
|
63651
|
-
var $isDocument = identity.isDocument;
|
|
63652
|
-
var $isMap = identity.isMap;
|
|
63653
|
-
var $isNode = identity.isNode;
|
|
63654
|
-
var $isPair = identity.isPair;
|
|
63655
|
-
var $isScalar = identity.isScalar;
|
|
63656
|
-
var $isSeq = identity.isSeq;
|
|
63657
|
-
var $Pair = Pair.Pair;
|
|
63658
|
-
var $Scalar = Scalar.Scalar;
|
|
63659
|
-
var $YAMLMap = YAMLMap.YAMLMap;
|
|
63660
|
-
var $YAMLSeq = YAMLSeq.YAMLSeq;
|
|
63661
|
-
var $Lexer = lexer.Lexer;
|
|
63662
|
-
var $LineCounter = lineCounter.LineCounter;
|
|
63663
|
-
var $Parser = parser.Parser;
|
|
63664
|
-
var $parse = publicApi.parse;
|
|
63665
|
-
var $parseAllDocuments = publicApi.parseAllDocuments;
|
|
63666
|
-
var $parseDocument = publicApi.parseDocument;
|
|
63667
|
-
var $stringify = publicApi.stringify;
|
|
63668
|
-
var $visit = visit.visit;
|
|
63669
|
-
var $visitAsync = visit.visitAsync;
|
|
63670
|
-
|
|
63671
64830
|
// ../../packages/praxis/deploy-core/src/workspace.ts
|
|
63672
64831
|
function packageJsonIn(dir) {
|
|
63673
64832
|
return dir === "." ? "package.json" : `${dir}/package.json`;
|
|
@@ -63679,6 +64838,16 @@ function dirOfPackageJson(path) {
|
|
|
63679
64838
|
return;
|
|
63680
64839
|
return path.slice(0, -"/package.json".length);
|
|
63681
64840
|
}
|
|
64841
|
+
function packageDirOf(path, dirs) {
|
|
64842
|
+
let found = null;
|
|
64843
|
+
for (const dir of dirs) {
|
|
64844
|
+
if (path !== dir && !path.startsWith(`${dir}/`))
|
|
64845
|
+
continue;
|
|
64846
|
+
if (found === null || dir.length > found.length)
|
|
64847
|
+
found = dir;
|
|
64848
|
+
}
|
|
64849
|
+
return found;
|
|
64850
|
+
}
|
|
63682
64851
|
function dirOfManifest(path) {
|
|
63683
64852
|
for (const name of BUILD_MANIFESTS) {
|
|
63684
64853
|
if (path === name)
|
|
@@ -64086,68 +65255,216 @@ function stronglyConnected(count3, edges) {
|
|
|
64086
65255
|
visit2(node2);
|
|
64087
65256
|
return components;
|
|
64088
65257
|
}
|
|
64089
|
-
// ../../packages/praxis/deploy-core/src/
|
|
64090
|
-
var
|
|
64091
|
-
var
|
|
64092
|
-
function
|
|
64093
|
-
|
|
64094
|
-
|
|
64095
|
-
|
|
64096
|
-
|
|
64097
|
-
|
|
64098
|
-
|
|
64099
|
-
|
|
64100
|
-
|
|
64101
|
-
return { jobState: "skipped", jobRunState: "unspecified" };
|
|
65258
|
+
// ../../packages/praxis/deploy-core/src/root-ownership.ts
|
|
65259
|
+
var ROOT_OWNERSHIP_FILE = "root-ownership.yaml";
|
|
65260
|
+
var ROOT_OWNERSHIP_DEFAULT = "widen";
|
|
65261
|
+
function rootPatternMatches(match, path) {
|
|
65262
|
+
const directory = match.endsWith("/");
|
|
65263
|
+
const pattern = match.replace(/^\.\//, "").replace(/\/+$/, "");
|
|
65264
|
+
if (!directory)
|
|
65265
|
+
return matchesPattern(pattern, path);
|
|
65266
|
+
const segments = path.split("/");
|
|
65267
|
+
for (let take = 1;take <= segments.length; take += 1) {
|
|
65268
|
+
if (matchesPattern(pattern, segments.slice(0, take).join("/")))
|
|
65269
|
+
return true;
|
|
64102
65270
|
}
|
|
65271
|
+
return false;
|
|
64103
65272
|
}
|
|
64104
|
-
function
|
|
64105
|
-
|
|
64106
|
-
|
|
64107
|
-
|
|
64108
|
-
|
|
64109
|
-
|
|
64110
|
-
|
|
64111
|
-
|
|
64112
|
-
|
|
64113
|
-
if (!Number.isFinite(minutes) || minutes <= 0)
|
|
64114
|
-
throw new Error(`--expire-minutes must be a positive number, got ${JSON.stringify(expireMinutes)}`);
|
|
64115
|
-
return new Date(start + minutes * 60000).toISOString();
|
|
64116
|
-
}
|
|
64117
|
-
function decidePhaseState(states) {
|
|
64118
|
-
if (states.length === 0)
|
|
64119
|
-
return "unspecified";
|
|
64120
|
-
if (states.some((state) => state === "failed" || state === "aborted"))
|
|
64121
|
-
return "failed";
|
|
64122
|
-
if (states.some((state) => state === "in_progress" || state === "pending"))
|
|
64123
|
-
return "in_progress";
|
|
64124
|
-
const neverRan = states.every((state) => state === "skipped" || state === "disabled");
|
|
64125
|
-
return neverRan ? "skipped" : "succeeded";
|
|
64126
|
-
}
|
|
64127
|
-
function decideRolloutState(jobs, options = {}) {
|
|
64128
|
-
const states = [...jobs.values()];
|
|
64129
|
-
if (states.some((state) => state === "failed" || state === "aborted"))
|
|
64130
|
-
return "failed";
|
|
64131
|
-
const deploy = jobs.get("deploy");
|
|
64132
|
-
if (deploy === undefined || deploy === "pending" || deploy === "in_progress" || deploy === "disabled")
|
|
64133
|
-
return "pending";
|
|
64134
|
-
if (deploy === "skipped" && options.artifactIdentical !== true)
|
|
64135
|
-
return "pending";
|
|
64136
|
-
if (states.every((state) => state === "succeeded" || state === "skipped" || state === "disabled" || state === "ignored")) {
|
|
64137
|
-
return options.artifactIdentical === true ? "skipped" : "succeeded";
|
|
65273
|
+
function rootOwnershipMatchOf(path, table) {
|
|
65274
|
+
if (table === null)
|
|
65275
|
+
return { kind: "unknown" };
|
|
65276
|
+
for (const rule of table.rules) {
|
|
65277
|
+
if (!rootPatternMatches(rule.match, path))
|
|
65278
|
+
continue;
|
|
65279
|
+
if (rule.kind === "package")
|
|
65280
|
+
return { kind: "package", package: rule.package ?? "" };
|
|
65281
|
+
return { kind: rule.kind };
|
|
64138
65282
|
}
|
|
64139
|
-
return "
|
|
65283
|
+
return { kind: "unknown" };
|
|
64140
65284
|
}
|
|
64141
|
-
|
|
64142
|
-
|
|
64143
|
-
|
|
64144
|
-
|
|
64145
|
-
|
|
64146
|
-
|
|
64147
|
-
|
|
64148
|
-
|
|
64149
|
-
|
|
64150
|
-
|
|
65285
|
+
var KINDS = ["resolving", "package", "none"];
|
|
65286
|
+
function parseRootOwnership(text, options) {
|
|
65287
|
+
if (text === null) {
|
|
65288
|
+
return {
|
|
65289
|
+
kind: "invalid",
|
|
65290
|
+
problems: [
|
|
65291
|
+
{
|
|
65292
|
+
rule: -1,
|
|
65293
|
+
match: ROOT_OWNERSHIP_FILE,
|
|
65294
|
+
problem: `${ROOT_OWNERSHIP_FILE} is missing at this commit`
|
|
65295
|
+
}
|
|
65296
|
+
]
|
|
65297
|
+
};
|
|
65298
|
+
}
|
|
65299
|
+
let parsed;
|
|
65300
|
+
try {
|
|
65301
|
+
parsed = $parse(text);
|
|
65302
|
+
} catch (error) {
|
|
65303
|
+
return {
|
|
65304
|
+
kind: "invalid",
|
|
65305
|
+
problems: [
|
|
65306
|
+
{ rule: -1, match: ROOT_OWNERSHIP_FILE, problem: `not YAML: ${error.message}` }
|
|
65307
|
+
]
|
|
65308
|
+
};
|
|
65309
|
+
}
|
|
65310
|
+
const problems = [];
|
|
65311
|
+
const document2 = parsed ?? null;
|
|
65312
|
+
if (document2 === null || typeof document2 !== "object" || Array.isArray(document2)) {
|
|
65313
|
+
return {
|
|
65314
|
+
kind: "invalid",
|
|
65315
|
+
problems: [
|
|
65316
|
+
{ rule: -1, match: ROOT_OWNERSHIP_FILE, problem: "the document is not a mapping" }
|
|
65317
|
+
]
|
|
65318
|
+
};
|
|
65319
|
+
}
|
|
65320
|
+
if (document2.version !== 1) {
|
|
65321
|
+
problems.push({
|
|
65322
|
+
rule: -1,
|
|
65323
|
+
match: "version",
|
|
65324
|
+
problem: `version must be 1, found ${JSON.stringify(document2.version)}`
|
|
65325
|
+
});
|
|
65326
|
+
}
|
|
65327
|
+
if (document2.default !== ROOT_OWNERSHIP_DEFAULT) {
|
|
65328
|
+
problems.push({
|
|
65329
|
+
rule: -1,
|
|
65330
|
+
match: "default",
|
|
65331
|
+
problem: `default must be "${ROOT_OWNERSHIP_DEFAULT}" — a path no rule claims may never narrow the run`
|
|
65332
|
+
});
|
|
65333
|
+
}
|
|
65334
|
+
if (!Array.isArray(document2.rules)) {
|
|
65335
|
+
problems.push({ rule: -1, match: "rules", problem: "rules must be a list" });
|
|
65336
|
+
return { kind: "invalid", problems };
|
|
65337
|
+
}
|
|
65338
|
+
const workspace = new Set(options.workspaceDirs);
|
|
65339
|
+
const rules = [];
|
|
65340
|
+
document2.rules.forEach((entry, index) => {
|
|
65341
|
+
const rule = entry ?? null;
|
|
65342
|
+
if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
|
|
65343
|
+
problems.push({
|
|
65344
|
+
rule: index,
|
|
65345
|
+
match: "",
|
|
65346
|
+
problem: "a rule must be a mapping with match and kind"
|
|
65347
|
+
});
|
|
65348
|
+
return;
|
|
65349
|
+
}
|
|
65350
|
+
const match = typeof rule.match === "string" ? rule.match.trim() : "";
|
|
65351
|
+
const kind = typeof rule.kind === "string" ? rule.kind : "";
|
|
65352
|
+
if (match === "") {
|
|
65353
|
+
problems.push({ rule: index, match: "", problem: "match must be a non-empty string" });
|
|
65354
|
+
return;
|
|
65355
|
+
}
|
|
65356
|
+
if (!KINDS.includes(kind)) {
|
|
65357
|
+
problems.push({
|
|
65358
|
+
rule: index,
|
|
65359
|
+
match,
|
|
65360
|
+
problem: `kind must be one of ${KINDS.join(" / ")}, found ${JSON.stringify(rule.kind)}`
|
|
65361
|
+
});
|
|
65362
|
+
return;
|
|
65363
|
+
}
|
|
65364
|
+
const evidence = typeof rule.evidence === "string" ? rule.evidence.trim() : "";
|
|
65365
|
+
const why = typeof rule.why === "string" ? rule.why.trim() : "";
|
|
65366
|
+
if (kind === "package") {
|
|
65367
|
+
const owner = typeof rule.package === "string" ? rule.package.trim() : "";
|
|
65368
|
+
if (owner === "") {
|
|
65369
|
+
problems.push({
|
|
65370
|
+
rule: index,
|
|
65371
|
+
match,
|
|
65372
|
+
problem: "kind: package needs the workspace directory it belongs to"
|
|
65373
|
+
});
|
|
65374
|
+
return;
|
|
65375
|
+
}
|
|
65376
|
+
if (!workspace.has(owner)) {
|
|
65377
|
+
problems.push({
|
|
65378
|
+
rule: index,
|
|
65379
|
+
match,
|
|
65380
|
+
problem: `package "${owner}" is not a workspace package directory at this commit`
|
|
65381
|
+
});
|
|
65382
|
+
return;
|
|
65383
|
+
}
|
|
65384
|
+
if (evidence === "") {
|
|
65385
|
+
rules.push({ match, kind: "resolving", evidenceMissing: true, ...why === "" ? {} : { why } });
|
|
65386
|
+
return;
|
|
65387
|
+
}
|
|
65388
|
+
rules.push({ match, kind: "package", package: owner, evidence, ...why === "" ? {} : { why } });
|
|
65389
|
+
return;
|
|
65390
|
+
}
|
|
65391
|
+
if (rule.package !== undefined) {
|
|
65392
|
+
problems.push({
|
|
65393
|
+
rule: index,
|
|
65394
|
+
match,
|
|
65395
|
+
problem: `package is only allowed on kind: package (this rule is ${kind})`
|
|
65396
|
+
});
|
|
65397
|
+
return;
|
|
65398
|
+
}
|
|
65399
|
+
if (kind === "none" && evidence === "") {
|
|
65400
|
+
rules.push({ match, kind: "resolving", evidenceMissing: true, ...why === "" ? {} : { why } });
|
|
65401
|
+
return;
|
|
65402
|
+
}
|
|
65403
|
+
rules.push({
|
|
65404
|
+
match,
|
|
65405
|
+
kind,
|
|
65406
|
+
...evidence === "" ? {} : { evidence },
|
|
65407
|
+
...why === "" ? {} : { why }
|
|
65408
|
+
});
|
|
65409
|
+
});
|
|
65410
|
+
if (problems.length > 0)
|
|
65411
|
+
return { kind: "invalid", problems };
|
|
65412
|
+
const table = { version: 1, rules, default: ROOT_OWNERSHIP_DEFAULT };
|
|
65413
|
+
if (rootOwnershipMatchOf(ROOT_OWNERSHIP_FILE, table).kind !== "resolving") {
|
|
65414
|
+
return {
|
|
65415
|
+
kind: "invalid",
|
|
65416
|
+
problems: [
|
|
65417
|
+
{
|
|
65418
|
+
rule: -1,
|
|
65419
|
+
match: ROOT_OWNERSHIP_FILE,
|
|
65420
|
+
problem: `${ROOT_OWNERSHIP_FILE} must classify itself as resolving: a change to the table can change every package's inputs`
|
|
65421
|
+
}
|
|
65422
|
+
]
|
|
65423
|
+
};
|
|
65424
|
+
}
|
|
65425
|
+
return { kind: "table", table };
|
|
65426
|
+
}
|
|
65427
|
+
function namedPackagesOf(input) {
|
|
65428
|
+
const named = new Set;
|
|
65429
|
+
for (const path of input.changedPaths) {
|
|
65430
|
+
const dir = packageDirOf(path, input.workspaceDirs);
|
|
65431
|
+
if (dir !== null)
|
|
65432
|
+
named.add(dir);
|
|
65433
|
+
}
|
|
65434
|
+
const roots = rootOwnershipDecisionOf(input);
|
|
65435
|
+
for (const dir of roots.packages)
|
|
65436
|
+
if (input.workspaceDirs.includes(dir))
|
|
65437
|
+
named.add(dir);
|
|
65438
|
+
return { packages: roots.widened ? [] : [...named].sort(), roots };
|
|
65439
|
+
}
|
|
65440
|
+
function rootOwnershipDecisionOf(input) {
|
|
65441
|
+
const unclaimed = input.changedPaths.filter((path) => packageDirOf(path, input.workspaceDirs) === null);
|
|
65442
|
+
const named = new Set;
|
|
65443
|
+
const traces = [];
|
|
65444
|
+
let widened = false;
|
|
65445
|
+
for (const path of unclaimed) {
|
|
65446
|
+
if (input.table === null) {
|
|
65447
|
+
widened = true;
|
|
65448
|
+
traces.push({ path, reason: "table-unreadable" });
|
|
65449
|
+
continue;
|
|
65450
|
+
}
|
|
65451
|
+
const match = rootOwnershipMatchOf(path, input.table);
|
|
65452
|
+
if (match.kind === "package")
|
|
65453
|
+
named.add(match.package);
|
|
65454
|
+
else if (match.kind === "none")
|
|
65455
|
+
continue;
|
|
65456
|
+
else {
|
|
65457
|
+
widened = true;
|
|
65458
|
+
traces.push({ path, reason: match.kind });
|
|
65459
|
+
}
|
|
65460
|
+
}
|
|
65461
|
+
return {
|
|
65462
|
+
unclaimed,
|
|
65463
|
+
widened,
|
|
65464
|
+
traces,
|
|
65465
|
+
packages: widened ? [] : [...named].sort(),
|
|
65466
|
+
allNone: !widened && unclaimed.length > 0 && named.size === 0
|
|
65467
|
+
};
|
|
64151
65468
|
}
|
|
64152
65469
|
// ../../packages/praxis/deploy-core/src/job-events-file.ts
|
|
64153
65470
|
import { appendFileSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
|
|
@@ -64266,7 +65583,7 @@ function reportBlockedTarget(events, target, message) {
|
|
|
64266
65583
|
}
|
|
64267
65584
|
|
|
64268
65585
|
// src/commands/devops.ts
|
|
64269
|
-
var
|
|
65586
|
+
var import_yaml4 = __toESM(require_dist(), 1);
|
|
64270
65587
|
|
|
64271
65588
|
// src/commands/devops-deploy-plan.ts
|
|
64272
65589
|
import { resolve as resolve3 } from "node:path";
|
|
@@ -65651,7 +66968,7 @@ async function devopsDeployTofu(flags, ports) {
|
|
|
65651
66968
|
const projectYaml = await ports.readFile(join5(ports.cwd, "praxis.yaml"));
|
|
65652
66969
|
let parsedYaml;
|
|
65653
66970
|
try {
|
|
65654
|
-
parsedYaml = projectYaml === null ? undefined :
|
|
66971
|
+
parsedYaml = projectYaml === null ? undefined : import_yaml4.parse(projectYaml);
|
|
65655
66972
|
} catch (error) {
|
|
65656
66973
|
throw new UsageError(`praxis.yaml is not valid YAML: ${error.message}`);
|
|
65657
66974
|
}
|
|
@@ -65901,17 +67218,6 @@ function selectAffected(input) {
|
|
|
65901
67218
|
reasons[spelled.get(relative2)] = reason;
|
|
65902
67219
|
return { tests: selected.map(({ relative: relative2 }) => spelled.get(relative2)), features, reasons, openIssues: [...AFFECTED_OPEN_ISSUES] };
|
|
65903
67220
|
}
|
|
65904
|
-
function nearestPackage(path, packages) {
|
|
65905
|
-
let found = null;
|
|
65906
|
-
for (const candidate of packages) {
|
|
65907
|
-
const root = candidate.replace(/\/+$/, "");
|
|
65908
|
-
if (!root || !(path === root || path.startsWith(`${root}/`)))
|
|
65909
|
-
continue;
|
|
65910
|
-
if (found === null || root.length > found.length)
|
|
65911
|
-
found = root;
|
|
65912
|
-
}
|
|
65913
|
-
return found;
|
|
65914
|
-
}
|
|
65915
67221
|
var BUN_FILE_HEADER = /^(\S.*\.(?:test|spec)\.(?:ts|tsx|js|mjs)):$/;
|
|
65916
67222
|
var BUN_COUNT = /^\s*(\d+)\s+(pass|fail|skip|todo)\b/;
|
|
65917
67223
|
var BUN_RAN = /^Ran (\d+) tests? across/;
|
|
@@ -66038,38 +67344,69 @@ async function changedSelection(since, ports) {
|
|
|
66038
67344
|
const roots = await ports.checkout.roots();
|
|
66039
67345
|
const grouped = new Map;
|
|
66040
67346
|
for (const file of files) {
|
|
66041
|
-
const owner =
|
|
67347
|
+
const owner = packageDirOf(file, roots);
|
|
66042
67348
|
if (owner === null)
|
|
66043
67349
|
continue;
|
|
66044
67350
|
grouped.set(owner, [...grouped.get(owner) ?? [], file]);
|
|
66045
67351
|
}
|
|
67352
|
+
const parsed = parseRootOwnership(await ports.checkout.read(ROOT_OWNERSHIP_FILE), { workspaceDirs: roots });
|
|
67353
|
+
const named = namedPackagesOf({ changedPaths: files, workspaceDirs: roots, table: parsed.kind === "table" ? parsed.table : null });
|
|
67354
|
+
const widen = named.roots.widened ? { paths: named.roots.traces.map((trace) => trace.path), reason: widenReason(named.roots.traces.map((trace) => trace.reason)) } : null;
|
|
67355
|
+
const failed = widen === null && files.length > 0 && named.packages.length === 0 && !named.roots.allNone ? { paths: [...named.roots.unclaimed].sort() } : null;
|
|
67356
|
+
const namedByTable = new Set(named.packages.filter((dir) => !grouped.has(dir)));
|
|
67357
|
+
const selectedRoots = widen !== null ? [...roots].sort((a, b) => a.localeCompare(b, "en")) : [...new Set([...grouped.keys(), ...namedByTable])].sort((a, b) => a.localeCompare(b, "en"));
|
|
66046
67358
|
const groups = [];
|
|
66047
|
-
for (const root of
|
|
67359
|
+
for (const root of selectedRoots) {
|
|
66048
67360
|
const packagePath = join6(ports.checkout.root, root);
|
|
66049
|
-
groups.push({
|
|
67361
|
+
groups.push({
|
|
67362
|
+
root,
|
|
67363
|
+
path: packagePath,
|
|
67364
|
+
whole: widen !== null || namedByTable.has(root),
|
|
67365
|
+
selection: selectAffected({ changed: grouped.get(root) ?? [], files: await ports.checkout.sources(packagePath), packageRoot: root })
|
|
67366
|
+
});
|
|
66050
67367
|
}
|
|
66051
67368
|
const owned = new Set([...grouped.values()].flat());
|
|
66052
|
-
return { base, files, groups, unowned: files.filter((file) => !owned.has(file)) };
|
|
67369
|
+
return { base, files, groups, unowned: files.filter((file) => !owned.has(file)), widen, failed };
|
|
67370
|
+
}
|
|
67371
|
+
function widenReason(reasons) {
|
|
67372
|
+
if (reasons.includes("table-unreadable"))
|
|
67373
|
+
return `${ROOT_OWNERSHIP_FILE} 读不出来(缺失或不合法),按整仓跑`;
|
|
67374
|
+
if (reasons.includes("unknown"))
|
|
67375
|
+
return "有仓库根路径没被表判定,按整仓跑";
|
|
67376
|
+
return "改到了仓库根的解析类文件(整仓都可能受影响)";
|
|
66053
67377
|
}
|
|
66054
67378
|
async function runAffected(list, since, ports) {
|
|
66055
|
-
const { base, files, groups, unowned } = await changedSelection(since, ports);
|
|
67379
|
+
const { base, files, groups, unowned, widen, failed } = await changedSelection(since, ports);
|
|
66056
67380
|
const view = {
|
|
66057
67381
|
since: base,
|
|
66058
67382
|
packages: groups.map((group) => ({
|
|
66059
67383
|
path: group.root,
|
|
66060
67384
|
tests: group.selection.tests.map((file) => ({ file, reason: group.selection.reasons[file] })),
|
|
66061
|
-
features: group.selection.features
|
|
67385
|
+
features: group.selection.features,
|
|
67386
|
+
...group.whole ? { whole: true } : {}
|
|
66062
67387
|
})),
|
|
66063
67388
|
tests: groups.flatMap((group) => group.selection.tests),
|
|
66064
67389
|
features: groups.flatMap((group) => group.selection.features),
|
|
66065
67390
|
unowned,
|
|
67391
|
+
widen,
|
|
67392
|
+
failed,
|
|
66066
67393
|
openIssues: [...selectAffected({ changed: [], files: new Map, packageRoot: "" }).openIssues]
|
|
66067
67394
|
};
|
|
66068
|
-
const lines = [
|
|
66069
|
-
...
|
|
66070
|
-
...
|
|
66071
|
-
|
|
66072
|
-
|
|
67395
|
+
const lines = [
|
|
67396
|
+
...widen === null ? [] : [`${widen.reason}:${widen.paths.join("、")} → 每个包整套测试`],
|
|
67397
|
+
...view.packages.flatMap((entry) => [
|
|
67398
|
+
...entry.tests.map(({ file, reason }) => `${file} (${reason})`),
|
|
67399
|
+
...entry.features.map((feature) => `${feature.file} (feature: ${feature.title})`)
|
|
67400
|
+
]),
|
|
67401
|
+
...view.openIssues.map((issue) => `note: ${issue}`)
|
|
67402
|
+
];
|
|
67403
|
+
if (failed !== null) {
|
|
67404
|
+
ports.emit({ kind: "object", data: view });
|
|
67405
|
+
ports.human([`选包塌成 0 个包:这些仓库根路径没有对应的包,也不在 ${ROOT_OWNERSHIP_FILE} 里被判成 none——先补表,别让它静默少跑:`, ...failed.paths].join(`
|
|
67406
|
+
`));
|
|
67407
|
+
return 1;
|
|
67408
|
+
}
|
|
67409
|
+
if (list || !groups.some((group) => group.whole) && view.tests.length === 0 && view.features.length === 0) {
|
|
66073
67410
|
ports.emit({ kind: "object", data: view });
|
|
66074
67411
|
ports.human([files.length === 0 ? `nothing changed since ${base}` : `${view.tests.length} test file(s) and ${view.features.length} feature(s) affected since ${base}:`, ...lines].join(`
|
|
66075
67412
|
`));
|
|
@@ -66077,9 +67414,9 @@ async function runAffected(list, since, ports) {
|
|
|
66077
67414
|
}
|
|
66078
67415
|
const runs = [];
|
|
66079
67416
|
for (const group of groups) {
|
|
66080
|
-
const
|
|
66081
|
-
if (
|
|
66082
|
-
const result = await ports.checkout.runTests(group.path,
|
|
67417
|
+
const selected = group.whole ? [] : group.selection.tests.map((file) => stripRoot(file, group.root));
|
|
67418
|
+
if (group.whole || selected.length) {
|
|
67419
|
+
const result = await ports.checkout.runTests(group.path, selected);
|
|
66083
67420
|
runs.push(bunTestRun(group.root, result.code, result.output));
|
|
66084
67421
|
}
|
|
66085
67422
|
for (const feature of group.selection.features)
|
|
@@ -66318,7 +67655,16 @@ async function localCheckout(cwd, spawn5) {
|
|
|
66318
67655
|
await walk(packagePath);
|
|
66319
67656
|
return files;
|
|
66320
67657
|
},
|
|
66321
|
-
runTests: (packagePath, files) => spawn5("nice", ["-n", "10", "bun", "test", ...files], { cwd: packagePath })
|
|
67658
|
+
runTests: (packagePath, files) => spawn5("nice", ["-n", "10", "bun", "test", ...files], { cwd: packagePath }),
|
|
67659
|
+
read: async (path) => {
|
|
67660
|
+
try {
|
|
67661
|
+
return await readFile4(join6(root, path), "utf8");
|
|
67662
|
+
} catch (error) {
|
|
67663
|
+
if (error.code === "ENOENT")
|
|
67664
|
+
return null;
|
|
67665
|
+
throw error;
|
|
67666
|
+
}
|
|
67667
|
+
}
|
|
66322
67668
|
};
|
|
66323
67669
|
}
|
|
66324
67670
|
async function withEngineStdoutOnStderr(body) {
|
|
@@ -66411,7 +67757,7 @@ function planContextCommand(command, flags, paths) {
|
|
|
66411
67757
|
import { join as join7, resolve as resolve7 } from "node:path";
|
|
66412
67758
|
|
|
66413
67759
|
// src/devops/flag.ts
|
|
66414
|
-
var DEFAULT_REGISTRY = "packages/praxis/
|
|
67760
|
+
var DEFAULT_REGISTRY = "packages/praxis/flags-client/src/flag-registry.generated.ts";
|
|
66415
67761
|
function registryFromProject(value) {
|
|
66416
67762
|
const section = (member4, key) => member4 !== null && typeof member4 === "object" && !Array.isArray(member4) ? member4[key] : undefined;
|
|
66417
67763
|
const registry = section(section(section(value, "devops"), "flags"), "registry");
|
|
@@ -66436,7 +67782,7 @@ function unknownFlag(key) {
|
|
|
66436
67782
|
function scaffoldCall(key) {
|
|
66437
67783
|
return [
|
|
66438
67784
|
`// Read once at the entry point, pass the boolean into pure code (skill feature-flag, 后端).`,
|
|
66439
|
-
`import { flagsFor, type FlagKey } from '@deepractice-ai/
|
|
67785
|
+
`import { flagsFor, type FlagKey } from '@deepractice-ai/flags-client';`,
|
|
66440
67786
|
``,
|
|
66441
67787
|
`const ${constantName(key)}: FlagKey = ${JSON.stringify(key)};`,
|
|
66442
67788
|
`// A devops key needs the ruleset binding, or it answers the code default forever.`,
|
|
@@ -69579,6 +70925,537 @@ async function canvasImport(args, ports) {
|
|
|
69579
70925
|
return 0;
|
|
69580
70926
|
}
|
|
69581
70927
|
|
|
70928
|
+
// src/commands/events-wait.ts
|
|
70929
|
+
var DEFAULT_AGENT = "R1M9TQ2X";
|
|
70930
|
+
var BASE_BACKOFF_MS = 1000;
|
|
70931
|
+
var MAX_BACKOFF_MS = 60000;
|
|
70932
|
+
var NOTICE_NAMED = 5;
|
|
70933
|
+
var ANNOUNCED_KEEP = 500;
|
|
70934
|
+
function assumeAgentOf(env) {
|
|
70935
|
+
return env.PRAXIS_ASSUME_AGENT?.trim() || DEFAULT_AGENT;
|
|
70936
|
+
}
|
|
70937
|
+
function sessionOf(raw) {
|
|
70938
|
+
if (raw === undefined)
|
|
70939
|
+
return null;
|
|
70940
|
+
const session = raw.trim();
|
|
70941
|
+
if (!/^[A-Za-z0-9_-]{1,128}$/.test(session))
|
|
70942
|
+
throw new Error("--session takes the Claude Code session id (letters, digits, - and _)");
|
|
70943
|
+
return session;
|
|
70944
|
+
}
|
|
70945
|
+
var keyPart = (part) => part.replace(/[^A-Za-z0-9_-]/g, "_");
|
|
70946
|
+
function waitKeyOf(env, agent, session) {
|
|
70947
|
+
return [env, agent, ...session === null ? [] : [session]].map(keyPart).join("-");
|
|
70948
|
+
}
|
|
70949
|
+
function pidOf(raw) {
|
|
70950
|
+
const pid = raw === null ? NaN : Number(raw.trim());
|
|
70951
|
+
return Number.isInteger(pid) && pid > 0 ? pid : null;
|
|
70952
|
+
}
|
|
70953
|
+
function lockDecision(recorded, self, probe) {
|
|
70954
|
+
if (recorded === null || recorded === self || probe === null || !probe.alive)
|
|
70955
|
+
return { kind: "take" };
|
|
70956
|
+
if (!/events\s+wait/.test(probe.command))
|
|
70957
|
+
return { kind: "take" };
|
|
70958
|
+
if (probe.ppid === 1)
|
|
70959
|
+
return { kind: "replace", pid: recorded };
|
|
70960
|
+
return { kind: "refuse", pid: recorded };
|
|
70961
|
+
}
|
|
70962
|
+
function alreadyWaitingNotice(pid) {
|
|
70963
|
+
return `本会话已有 praxis agent events wait 在后台等待(pid ${pid}),不用再启动。`;
|
|
70964
|
+
}
|
|
70965
|
+
async function acquireWaitLock(ports) {
|
|
70966
|
+
for (let attempt = 0;attempt < 3; attempt++) {
|
|
70967
|
+
const recorded = pidOf(await ports.readPid());
|
|
70968
|
+
if (recorded === null) {
|
|
70969
|
+
if (await ports.createPid(String(ports.self)))
|
|
70970
|
+
return null;
|
|
70971
|
+
continue;
|
|
70972
|
+
}
|
|
70973
|
+
const decision = lockDecision(recorded, ports.self, await ports.probe(recorded));
|
|
70974
|
+
if (decision.kind === "refuse")
|
|
70975
|
+
return decision.pid;
|
|
70976
|
+
if (decision.kind === "replace")
|
|
70977
|
+
ports.terminate(decision.pid);
|
|
70978
|
+
await ports.replacePid(String(ports.self));
|
|
70979
|
+
const holder = pidOf(await ports.readPid());
|
|
70980
|
+
return holder === ports.self || holder === null ? null : holder;
|
|
70981
|
+
}
|
|
70982
|
+
return pidOf(await ports.readPid());
|
|
70983
|
+
}
|
|
70984
|
+
function timeoutMsOf(raw) {
|
|
70985
|
+
if (raw === undefined)
|
|
70986
|
+
return null;
|
|
70987
|
+
const seconds = Number(raw);
|
|
70988
|
+
if (!/^\d+(\.\d+)?$/.test(raw.trim()) || !Number.isFinite(seconds) || seconds <= 0)
|
|
70989
|
+
throw new Error("--timeout takes a positive number of seconds");
|
|
70990
|
+
return Math.round(seconds * 1000);
|
|
70991
|
+
}
|
|
70992
|
+
function backoffMs(failures) {
|
|
70993
|
+
if (failures <= 0)
|
|
70994
|
+
return 0;
|
|
70995
|
+
return Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** Math.min(failures - 1, 16));
|
|
70996
|
+
}
|
|
70997
|
+
function inboxLettersUrl(apiUrl, agent) {
|
|
70998
|
+
return `${apiUrl}/agent/v1/agents/${encodeURIComponent(agent)}/inbox/letters?unread=true&limit=20`;
|
|
70999
|
+
}
|
|
71000
|
+
function eventsStreamUrl(apiUrl, agent) {
|
|
71001
|
+
return `${apiUrl}/agent/v1/agents/${encodeURIComponent(agent)}/events/stream`;
|
|
71002
|
+
}
|
|
71003
|
+
function streamHeaders(auth, lastEventId) {
|
|
71004
|
+
return { ...auth, Accept: "text/event-stream", ...lastEventId === null ? {} : { "Last-Event-ID": lastEventId } };
|
|
71005
|
+
}
|
|
71006
|
+
function lettersOf(body) {
|
|
71007
|
+
const value = body;
|
|
71008
|
+
if (!value || typeof value.unread !== "number" || !Array.isArray(value.letters))
|
|
71009
|
+
throw new Error("letters answer is not { unread, letters }");
|
|
71010
|
+
const letters = value.letters.filter((letter) => typeof letter === "object" && letter !== null && typeof letter.id === "string" && typeof letter.summary === "string");
|
|
71011
|
+
return { unread: value.unread, letters };
|
|
71012
|
+
}
|
|
71013
|
+
function feedSse(buffer, chunk) {
|
|
71014
|
+
const text2 = (buffer + chunk).replace(/\r\n?/g, `
|
|
71015
|
+
`);
|
|
71016
|
+
const blocks = text2.split(`
|
|
71017
|
+
|
|
71018
|
+
`);
|
|
71019
|
+
const rest = blocks.pop() ?? "";
|
|
71020
|
+
const frames = [];
|
|
71021
|
+
for (const block of blocks) {
|
|
71022
|
+
let event, id;
|
|
71023
|
+
const data = [];
|
|
71024
|
+
for (const line of block.split(`
|
|
71025
|
+
`)) {
|
|
71026
|
+
if (line === "" || line.startsWith(":"))
|
|
71027
|
+
continue;
|
|
71028
|
+
const colon = line.indexOf(":");
|
|
71029
|
+
const field = colon < 0 ? line : line.slice(0, colon);
|
|
71030
|
+
const value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
|
|
71031
|
+
if (field === "data")
|
|
71032
|
+
data.push(value);
|
|
71033
|
+
else if (field === "event")
|
|
71034
|
+
event = value;
|
|
71035
|
+
else if (field === "id")
|
|
71036
|
+
id = value;
|
|
71037
|
+
}
|
|
71038
|
+
if (data.length)
|
|
71039
|
+
frames.push({ ...event === undefined ? {} : { event }, ...id === undefined ? {} : { id }, data: data.join(`
|
|
71040
|
+
`) });
|
|
71041
|
+
}
|
|
71042
|
+
return { buffer: rest, frames };
|
|
71043
|
+
}
|
|
71044
|
+
var text2 = (value) => typeof value === "string" && value !== "";
|
|
71045
|
+
function wakeOf(frame) {
|
|
71046
|
+
let event;
|
|
71047
|
+
try {
|
|
71048
|
+
event = JSON.parse(frame.data);
|
|
71049
|
+
} catch {
|
|
71050
|
+
return null;
|
|
71051
|
+
}
|
|
71052
|
+
if (typeof event !== "object" || event === null)
|
|
71053
|
+
return null;
|
|
71054
|
+
if (event.type === "inbox.letter_delivered" && text2(event.letter_id) && typeof event.summary === "string")
|
|
71055
|
+
return { kind: "letter", letter: {
|
|
71056
|
+
id: event.letter_id,
|
|
71057
|
+
sender: typeof event.sender === "string" ? event.sender : "",
|
|
71058
|
+
...text2(event.sender_name) ? { sender_name: event.sender_name } : {},
|
|
71059
|
+
summary: event.summary,
|
|
71060
|
+
thread: typeof event.thread === "string" ? event.thread : null,
|
|
71061
|
+
create_time: typeof event.create_time === "string" ? event.create_time : ""
|
|
71062
|
+
} };
|
|
71063
|
+
if (event.type === "cognition.ritual_held" && text2(event.title))
|
|
71064
|
+
return { kind: "ritual", ritual: {
|
|
71065
|
+
ritual: text2(event.ritual) ? event.ritual : "",
|
|
71066
|
+
owner: text2(event.owner) ? event.owner : "",
|
|
71067
|
+
title: event.title,
|
|
71068
|
+
engram: text2(event.engram) ? event.engram : ""
|
|
71069
|
+
} };
|
|
71070
|
+
return null;
|
|
71071
|
+
}
|
|
71072
|
+
function ritualNotice(ritual) {
|
|
71073
|
+
const origin = [ritual.owner, ritual.ritual].filter(Boolean).join(" 的仪式 ");
|
|
71074
|
+
return `你获得了一段新记忆:「${ritual.title}」${origin ? `(${origin}${ritual.engram ? `,${ritual.engram}` : ""})` : ""}。处理完再在后台运行 praxis agent events wait。`;
|
|
71075
|
+
}
|
|
71076
|
+
function retryableStatus(status) {
|
|
71077
|
+
return status >= 500 || status === 408 || status === 429;
|
|
71078
|
+
}
|
|
71079
|
+
function planNotice(page, announced) {
|
|
71080
|
+
const seen = new Set(announced);
|
|
71081
|
+
const fresh = page.letters.filter((letter) => !seen.has(letter.id));
|
|
71082
|
+
if (!fresh.length)
|
|
71083
|
+
return { announced };
|
|
71084
|
+
const named = fresh.slice(0, NOTICE_NAMED).map((letter) => `${letter.sender_name || letter.sender}:${letter.summary}(${letter.id})`);
|
|
71085
|
+
const more = fresh.length > NOTICE_NAMED ? `;另有 ${fresh.length - NOTICE_NAMED} 封` : "";
|
|
71086
|
+
const notice = `你有 ${fresh.length} 封新信:${named.join(";")}${more}。用 praxis_assume_inbox(action "read")读取并处理,处理完再在后台运行 praxis agent events wait。`;
|
|
71087
|
+
const next = [...announced, ...fresh.map((letter) => letter.id)];
|
|
71088
|
+
return { notice, announced: next.length > ANNOUNCED_KEEP ? next.slice(next.length - ANNOUNCED_KEEP) : next };
|
|
71089
|
+
}
|
|
71090
|
+
function waitStateOf(raw) {
|
|
71091
|
+
if (raw === null)
|
|
71092
|
+
return { announced: [], lastEventId: null };
|
|
71093
|
+
try {
|
|
71094
|
+
const value = JSON.parse(raw);
|
|
71095
|
+
return {
|
|
71096
|
+
announced: Array.isArray(value.announced) ? value.announced.filter((id) => typeof id === "string") : [],
|
|
71097
|
+
lastEventId: typeof value.last_event_id === "string" && /^\d+$/.test(value.last_event_id) ? value.last_event_id : null
|
|
71098
|
+
};
|
|
71099
|
+
} catch {
|
|
71100
|
+
return { announced: [], lastEventId: null };
|
|
71101
|
+
}
|
|
71102
|
+
}
|
|
71103
|
+
function waitStateText(state) {
|
|
71104
|
+
return JSON.stringify({ announced: state.announced, ...state.lastEventId === null ? {} : { last_event_id: state.lastEventId } });
|
|
71105
|
+
}
|
|
71106
|
+
var message = (error) => error instanceof Error ? error.message : String(error);
|
|
71107
|
+
async function runEventsWait(ports) {
|
|
71108
|
+
const stop = new AbortController;
|
|
71109
|
+
let timedOut = false;
|
|
71110
|
+
const timer = ports.timeoutMs === null ? undefined : setTimeout(() => {
|
|
71111
|
+
timedOut = true;
|
|
71112
|
+
stop.abort();
|
|
71113
|
+
}, ports.timeoutMs);
|
|
71114
|
+
const state = await ports.readState();
|
|
71115
|
+
let announced = state.announced;
|
|
71116
|
+
let lastEventId = state.lastEventId;
|
|
71117
|
+
const announceLetters = async (page) => {
|
|
71118
|
+
const planned = planNotice(page, announced);
|
|
71119
|
+
if (!planned.notice)
|
|
71120
|
+
return false;
|
|
71121
|
+
announced = planned.announced;
|
|
71122
|
+
await ports.writeState({ announced, lastEventId });
|
|
71123
|
+
ports.print(planned.notice);
|
|
71124
|
+
return true;
|
|
71125
|
+
};
|
|
71126
|
+
const announce = async () => announceLetters(await ports.fetchLetters());
|
|
71127
|
+
try {
|
|
71128
|
+
try {
|
|
71129
|
+
if (await announce())
|
|
71130
|
+
return 0;
|
|
71131
|
+
} catch (error) {
|
|
71132
|
+
ports.log(`praxis agent events wait: reading letters failed: ${message(error)}`);
|
|
71133
|
+
}
|
|
71134
|
+
ports.log(`praxis agent events wait: waiting for letters to assume agent ${ports.agent}`);
|
|
71135
|
+
let failures = 0;
|
|
71136
|
+
while (!stop.signal.aborted) {
|
|
71137
|
+
if (failures)
|
|
71138
|
+
await ports.sleep(backoffMs(failures), stop.signal);
|
|
71139
|
+
if (stop.signal.aborted)
|
|
71140
|
+
break;
|
|
71141
|
+
try {
|
|
71142
|
+
const opened = await ports.openStream(stop.signal, lastEventId);
|
|
71143
|
+
if (opened.status < 200 || opened.status >= 300 || !opened.chunks) {
|
|
71144
|
+
if (!retryableStatus(opened.status)) {
|
|
71145
|
+
ports.log(`praxis agent events wait: the event stream was refused (HTTP ${opened.status}${opened.reason ? `: ${opened.reason}` : ""})`);
|
|
71146
|
+
return 1;
|
|
71147
|
+
}
|
|
71148
|
+
throw new Error(`HTTP ${opened.status}`);
|
|
71149
|
+
}
|
|
71150
|
+
if (await announce())
|
|
71151
|
+
return 0;
|
|
71152
|
+
if (failures)
|
|
71153
|
+
ports.log("praxis agent events wait: event stream reconnected");
|
|
71154
|
+
failures = 0;
|
|
71155
|
+
let buffer = "";
|
|
71156
|
+
for await (const chunk of opened.chunks) {
|
|
71157
|
+
const fed = feedSse(buffer, chunk);
|
|
71158
|
+
buffer = fed.buffer;
|
|
71159
|
+
for (const frame of fed.frames) {
|
|
71160
|
+
const wake = wakeOf(frame);
|
|
71161
|
+
if (wake !== null && frame.id !== undefined)
|
|
71162
|
+
lastEventId = frame.id;
|
|
71163
|
+
if (wake?.kind === "letter" && await announceLetters({ unread: 1, letters: [wake.letter] }))
|
|
71164
|
+
return 0;
|
|
71165
|
+
if (wake?.kind === "ritual") {
|
|
71166
|
+
await ports.writeState({ announced, lastEventId });
|
|
71167
|
+
ports.print(ritualNotice(wake.ritual));
|
|
71168
|
+
return 0;
|
|
71169
|
+
}
|
|
71170
|
+
}
|
|
71171
|
+
}
|
|
71172
|
+
throw new Error("the event stream ended");
|
|
71173
|
+
} catch (error) {
|
|
71174
|
+
if (stop.signal.aborted)
|
|
71175
|
+
break;
|
|
71176
|
+
failures += 1;
|
|
71177
|
+
ports.log(`praxis agent events wait: ${message(error)} (${failures} in a row, reconnecting in ${backoffMs(failures) / 1000}s)`);
|
|
71178
|
+
}
|
|
71179
|
+
}
|
|
71180
|
+
if (timedOut)
|
|
71181
|
+
ports.print(`${(ports.timeoutMs ?? 0) / 1000} 秒内没有新信。需要继续等待时再在后台运行 praxis agent events wait。`);
|
|
71182
|
+
return 0;
|
|
71183
|
+
} finally {
|
|
71184
|
+
if (timer)
|
|
71185
|
+
clearTimeout(timer);
|
|
71186
|
+
stop.abort();
|
|
71187
|
+
}
|
|
71188
|
+
}
|
|
71189
|
+
|
|
71190
|
+
// src/commands/events-channel.ts
|
|
71191
|
+
var CHANNEL_SOURCE = "assume-agent";
|
|
71192
|
+
var SERVER_NAME = "assume-channel";
|
|
71193
|
+
var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
|
|
71194
|
+
var BACKLOG_NAMED = 5;
|
|
71195
|
+
function channelInstructions(agent) {
|
|
71196
|
+
return [
|
|
71197
|
+
`Events from your Praxis assume agent ${agent} arrive as <channel source="${CHANNEL_SOURCE}" kind="letter" letter_id="…" sender="…">.`,
|
|
71198
|
+
'kind="letter": a letter reached the agent. The content names the sender and the summary; read the letters with the praxis_assume_inbox tool (action "read") and handle them.',
|
|
71199
|
+
'kind="ritual": the agent was given a new memory (a ritual was held); its knowledge is refreshed, nothing to reply to.',
|
|
71200
|
+
"The channel is one-way: answer through the praxis_assume_* tools, not back through the channel."
|
|
71201
|
+
].join(`
|
|
71202
|
+
`);
|
|
71203
|
+
}
|
|
71204
|
+
function initializeResult(params, agent) {
|
|
71205
|
+
const asked = params?.protocolVersion;
|
|
71206
|
+
return {
|
|
71207
|
+
protocolVersion: typeof asked === "string" ? asked : DEFAULT_PROTOCOL_VERSION,
|
|
71208
|
+
capabilities: { experimental: { "claude/channel": {} } },
|
|
71209
|
+
serverInfo: { name: SERVER_NAME, version: "0.1.0" },
|
|
71210
|
+
instructions: channelInstructions(agent)
|
|
71211
|
+
};
|
|
71212
|
+
}
|
|
71213
|
+
function replyTo(message2, agent) {
|
|
71214
|
+
if (message2.id === undefined || message2.id === null || typeof message2.method !== "string")
|
|
71215
|
+
return null;
|
|
71216
|
+
const reply = (body) => ({ jsonrpc: "2.0", id: message2.id, ...body });
|
|
71217
|
+
switch (message2.method) {
|
|
71218
|
+
case "initialize":
|
|
71219
|
+
return reply({ result: initializeResult(message2.params, agent) });
|
|
71220
|
+
case "ping":
|
|
71221
|
+
return reply({ result: {} });
|
|
71222
|
+
default:
|
|
71223
|
+
return reply({ error: { code: -32601, message: `Method not found: ${message2.method}` } });
|
|
71224
|
+
}
|
|
71225
|
+
}
|
|
71226
|
+
var sender = (letter) => letter.sender_name || letter.sender;
|
|
71227
|
+
var readHint = 'Read it with praxis_assume_inbox (action "read").';
|
|
71228
|
+
var frame = (content, meta) => ({ jsonrpc: "2.0", method: "notifications/claude/channel", params: { content, meta } });
|
|
71229
|
+
function letterNotification(letter) {
|
|
71230
|
+
return frame(`${sender(letter)}: ${letter.summary}
|
|
71231
|
+
${readHint}`, { kind: "letter", letter_id: letter.id, sender: letter.sender, ...letter.sender_name ? { sender_name: letter.sender_name } : {} });
|
|
71232
|
+
}
|
|
71233
|
+
function backlogNotification(letters) {
|
|
71234
|
+
const named = letters.slice(0, BACKLOG_NAMED).map((letter) => `${sender(letter)}: ${letter.summary} (${letter.id})`);
|
|
71235
|
+
const more = letters.length > BACKLOG_NAMED ? `; ${letters.length - BACKLOG_NAMED} more` : "";
|
|
71236
|
+
return frame(`${letters.length} unread letter(s) waiting: ${named.join("; ")}${more}
|
|
71237
|
+
${readHint}`, { kind: "letter", letter_id: letters[0].id, sender: letters[0].sender, count: String(letters.length) });
|
|
71238
|
+
}
|
|
71239
|
+
function ritualNotification(ritual) {
|
|
71240
|
+
return frame(`New memory: "${ritual.title}"${ritual.owner ? ` (${ritual.owner}${ritual.ritual ? ` ${ritual.ritual}` : ""})` : ""}. Your knowledge is refreshed.`, { kind: "ritual", ...ritual.ritual ? { ritual: ritual.ritual } : {}, ...ritual.engram ? { engram: ritual.engram } : {} });
|
|
71241
|
+
}
|
|
71242
|
+
async function runChannel(ports) {
|
|
71243
|
+
const stop = new AbortController;
|
|
71244
|
+
const seen = new Set;
|
|
71245
|
+
let lastEventId = null;
|
|
71246
|
+
let follower = null;
|
|
71247
|
+
const fresh = (letters) => letters.filter((letter) => !seen.has(letter.id) && (seen.add(letter.id), true));
|
|
71248
|
+
const catchUp = async () => {
|
|
71249
|
+
const letters = fresh((await ports.fetchLetters()).letters);
|
|
71250
|
+
if (letters.length)
|
|
71251
|
+
ports.send(backlogNotification(letters));
|
|
71252
|
+
};
|
|
71253
|
+
const follow = async () => {
|
|
71254
|
+
let failures = 0;
|
|
71255
|
+
while (!stop.signal.aborted) {
|
|
71256
|
+
if (failures)
|
|
71257
|
+
await ports.sleep(backoffMs(failures), stop.signal);
|
|
71258
|
+
if (stop.signal.aborted)
|
|
71259
|
+
break;
|
|
71260
|
+
try {
|
|
71261
|
+
const opened = await ports.openStream(stop.signal, lastEventId);
|
|
71262
|
+
if (opened.status < 200 || opened.status >= 300 || !opened.chunks) {
|
|
71263
|
+
if (!retryableStatus(opened.status)) {
|
|
71264
|
+
ports.log(`assume-channel: the event stream was refused (HTTP ${opened.status}${opened.reason ? `: ${opened.reason}` : ""})`);
|
|
71265
|
+
return;
|
|
71266
|
+
}
|
|
71267
|
+
throw new Error(`HTTP ${opened.status}`);
|
|
71268
|
+
}
|
|
71269
|
+
try {
|
|
71270
|
+
await catchUp();
|
|
71271
|
+
} catch (error) {
|
|
71272
|
+
ports.log(`assume-channel: reading letters failed: ${error instanceof Error ? error.message : error}`);
|
|
71273
|
+
}
|
|
71274
|
+
if (failures)
|
|
71275
|
+
ports.log("assume-channel: event stream reconnected");
|
|
71276
|
+
failures = 0;
|
|
71277
|
+
let buffer2 = "";
|
|
71278
|
+
for await (const chunk of opened.chunks) {
|
|
71279
|
+
const fed = feedSse(buffer2, chunk);
|
|
71280
|
+
buffer2 = fed.buffer;
|
|
71281
|
+
for (const raw of fed.frames) {
|
|
71282
|
+
const wake = wakeOf(raw);
|
|
71283
|
+
if (wake === null)
|
|
71284
|
+
continue;
|
|
71285
|
+
if (raw.id !== undefined)
|
|
71286
|
+
lastEventId = raw.id;
|
|
71287
|
+
if (wake.kind === "letter") {
|
|
71288
|
+
if (fresh([wake.letter]).length)
|
|
71289
|
+
ports.send(letterNotification(wake.letter));
|
|
71290
|
+
} else
|
|
71291
|
+
ports.send(ritualNotification(wake.ritual));
|
|
71292
|
+
}
|
|
71293
|
+
}
|
|
71294
|
+
throw new Error("the event stream ended");
|
|
71295
|
+
} catch (error) {
|
|
71296
|
+
if (stop.signal.aborted)
|
|
71297
|
+
break;
|
|
71298
|
+
failures += 1;
|
|
71299
|
+
ports.log(`assume-channel: ${error instanceof Error ? error.message : error} (${failures} in a row, reconnecting in ${backoffMs(failures) / 1000}s)`);
|
|
71300
|
+
}
|
|
71301
|
+
}
|
|
71302
|
+
};
|
|
71303
|
+
let buffer = "";
|
|
71304
|
+
const handle = (line) => {
|
|
71305
|
+
if (!line.trim())
|
|
71306
|
+
return;
|
|
71307
|
+
let message2;
|
|
71308
|
+
try {
|
|
71309
|
+
message2 = JSON.parse(line);
|
|
71310
|
+
} catch {
|
|
71311
|
+
ports.log("assume-channel: ignored a line that is not JSON");
|
|
71312
|
+
return;
|
|
71313
|
+
}
|
|
71314
|
+
const reply = replyTo(message2, ports.agent);
|
|
71315
|
+
if (reply)
|
|
71316
|
+
ports.send(reply);
|
|
71317
|
+
if (message2.method === "notifications/initialized" && follower === null)
|
|
71318
|
+
follower = follow();
|
|
71319
|
+
};
|
|
71320
|
+
for await (const chunk of ports.input) {
|
|
71321
|
+
buffer += chunk;
|
|
71322
|
+
const lines = buffer.split(`
|
|
71323
|
+
`);
|
|
71324
|
+
buffer = lines.pop() ?? "";
|
|
71325
|
+
for (const line of lines)
|
|
71326
|
+
handle(line);
|
|
71327
|
+
}
|
|
71328
|
+
handle(buffer);
|
|
71329
|
+
stop.abort();
|
|
71330
|
+
await follower;
|
|
71331
|
+
return 0;
|
|
71332
|
+
}
|
|
71333
|
+
|
|
71334
|
+
// src/commands/agent-memory.ts
|
|
71335
|
+
var MEMORY_TOOL = "praxis_assume_memory";
|
|
71336
|
+
var RECALL_TOOL = "praxis_assume_recall";
|
|
71337
|
+
var REMEMBER_TOOL = "praxis_assume_remember";
|
|
71338
|
+
function mcpUrl(apiUrl, agent) {
|
|
71339
|
+
return `${apiUrl}/agent/v1/agents/${encodeURIComponent(agent)}/mcp`;
|
|
71340
|
+
}
|
|
71341
|
+
function rpcAnswerOf(body, id) {
|
|
71342
|
+
const candidates2 = body.trimStart().startsWith("{") ? [body] : body.split(`
|
|
71343
|
+
`).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
|
|
71344
|
+
for (const candidate of candidates2) {
|
|
71345
|
+
try {
|
|
71346
|
+
const parsed = JSON.parse(candidate);
|
|
71347
|
+
if (parsed.id === id)
|
|
71348
|
+
return parsed;
|
|
71349
|
+
} catch {}
|
|
71350
|
+
}
|
|
71351
|
+
return null;
|
|
71352
|
+
}
|
|
71353
|
+
function toolTextOf(result) {
|
|
71354
|
+
const value = result;
|
|
71355
|
+
const text3 = (value?.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
|
|
71356
|
+
`).trim();
|
|
71357
|
+
return value?.isError === true ? { ok: false, reason: text3 || "the tool refused" } : { ok: true, text: text3 };
|
|
71358
|
+
}
|
|
71359
|
+
async function callAgentTool(ports, url, name, args, signal) {
|
|
71360
|
+
const base = { ...await ports.headers(), "Content-Type": "application/json", Accept: "application/json, text/event-stream" };
|
|
71361
|
+
const post = (body, session2) => ports.fetch(url, {
|
|
71362
|
+
method: "POST",
|
|
71363
|
+
headers: { ...base, ...session2 === undefined ? {} : { "Mcp-Session-Id": session2 } },
|
|
71364
|
+
body: JSON.stringify(body),
|
|
71365
|
+
...signal === undefined ? {} : { signal },
|
|
71366
|
+
redirect: "error"
|
|
71367
|
+
});
|
|
71368
|
+
const init = await post({ jsonrpc: "2.0", id: 1, method: "initialize", params: {
|
|
71369
|
+
protocolVersion: "2025-06-18",
|
|
71370
|
+
capabilities: {},
|
|
71371
|
+
clientInfo: { name: "praxis-cli-memory", version: "1" }
|
|
71372
|
+
} });
|
|
71373
|
+
const initBody = await init.text();
|
|
71374
|
+
if (!init.ok)
|
|
71375
|
+
throw new Error(`HTTP ${init.status} on initialize`);
|
|
71376
|
+
const session = init.headers.get("Mcp-Session-Id") ?? undefined;
|
|
71377
|
+
const initAnswer = rpcAnswerOf(initBody, 1);
|
|
71378
|
+
if (initAnswer?.error)
|
|
71379
|
+
throw new Error(initAnswer.error.message ?? "initialize failed");
|
|
71380
|
+
await post({ jsonrpc: "2.0", method: "notifications/initialized" }, session).then((r) => r.text()).catch(() => "");
|
|
71381
|
+
const call3 = await post({ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name, arguments: args } }, session);
|
|
71382
|
+
const callBody = await call3.text();
|
|
71383
|
+
if (!call3.ok)
|
|
71384
|
+
throw new Error(`HTTP ${call3.status} on ${name}`);
|
|
71385
|
+
const answer = rpcAnswerOf(callBody, 2);
|
|
71386
|
+
if (answer === null)
|
|
71387
|
+
throw new Error(`no answer from ${name}`);
|
|
71388
|
+
if (answer.error)
|
|
71389
|
+
throw new Error(answer.error.message ?? `${name} failed`);
|
|
71390
|
+
const text3 = toolTextOf(answer.result);
|
|
71391
|
+
if (!text3.ok)
|
|
71392
|
+
throw new Error(text3.reason);
|
|
71393
|
+
return text3.text;
|
|
71394
|
+
}
|
|
71395
|
+
function memoryBodyOf(text3) {
|
|
71396
|
+
return text3.split(`
|
|
71397
|
+
`).filter((line) => {
|
|
71398
|
+
const trimmed = line.trim();
|
|
71399
|
+
return !/^shell: acon_/.test(trimmed) && !/^你有 \d+ 封未读信/.test(trimmed) && !/^You have \d+ unread letter/.test(trimmed);
|
|
71400
|
+
}).join(`
|
|
71401
|
+
`).trim();
|
|
71402
|
+
}
|
|
71403
|
+
function paragraphKey(paragraph) {
|
|
71404
|
+
return paragraph.replace(/\s*\[n\d+\]/g, "").replace(/\s+/g, " ").trim();
|
|
71405
|
+
}
|
|
71406
|
+
function newParagraphs(memory, seen) {
|
|
71407
|
+
const seenKeys = new Set([...seen].map(paragraphKey));
|
|
71408
|
+
return memory.split(/\n{2,}/).map((part) => part.trim()).filter((part) => part !== "" && !seenKeys.has(paragraphKey(part)));
|
|
71409
|
+
}
|
|
71410
|
+
var MEMORY_FRAME = (body) => `<memory source="praxis-assume" note="your memory as this agent, drawn from your organization just now; recall with praxis_assume_recall">
|
|
71411
|
+
${body}
|
|
71412
|
+
</memory>`;
|
|
71413
|
+
var MEMORY_CHANGED_FRAME = (body) => `<memory_since_start source="praxis-assume" note="what came to mind since this conversation last read your memory">
|
|
71414
|
+
${body}
|
|
71415
|
+
</memory_since_start>`;
|
|
71416
|
+
function hookOutput(event, context) {
|
|
71417
|
+
if (context === null || context.trim() === "")
|
|
71418
|
+
return null;
|
|
71419
|
+
return JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: context } });
|
|
71420
|
+
}
|
|
71421
|
+
function hookInputOf(raw) {
|
|
71422
|
+
try {
|
|
71423
|
+
const parsed = JSON.parse(raw);
|
|
71424
|
+
const sessionId = typeof parsed.session_id === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(parsed.session_id) ? parsed.session_id : null;
|
|
71425
|
+
return { sessionId, source: typeof parsed.source === "string" ? parsed.source : null };
|
|
71426
|
+
} catch {
|
|
71427
|
+
return { sessionId: null, source: null };
|
|
71428
|
+
}
|
|
71429
|
+
}
|
|
71430
|
+
async function runMemoryHook(event, input, ports) {
|
|
71431
|
+
try {
|
|
71432
|
+
const memory = memoryBodyOf(await callAgentTool(ports, ports.url, MEMORY_TOOL, {}, AbortSignal.timeout(ports.timeoutMs)));
|
|
71433
|
+
if (memory === "")
|
|
71434
|
+
return null;
|
|
71435
|
+
const all = newParagraphs(memory, new Set);
|
|
71436
|
+
if (event === "SessionStart") {
|
|
71437
|
+
if (input.sessionId !== null)
|
|
71438
|
+
await ports.writeSeen(input.sessionId, all).catch(() => {
|
|
71439
|
+
return;
|
|
71440
|
+
});
|
|
71441
|
+
return hookOutput(event, MEMORY_FRAME(memory));
|
|
71442
|
+
}
|
|
71443
|
+
const seen = input.sessionId === null ? [] : await ports.readSeen(input.sessionId).catch(() => []);
|
|
71444
|
+
const fresh = newParagraphs(memory, new Set(seen));
|
|
71445
|
+
if (fresh.length === 0)
|
|
71446
|
+
return null;
|
|
71447
|
+
if (input.sessionId !== null)
|
|
71448
|
+
await ports.writeSeen(input.sessionId, [...seen, ...fresh]).catch(() => {
|
|
71449
|
+
return;
|
|
71450
|
+
});
|
|
71451
|
+
return hookOutput(event, MEMORY_CHANGED_FRAME(fresh.join(`
|
|
71452
|
+
|
|
71453
|
+
`)));
|
|
71454
|
+
} catch {
|
|
71455
|
+
return null;
|
|
71456
|
+
}
|
|
71457
|
+
}
|
|
71458
|
+
|
|
69582
71459
|
// src/main.ts
|
|
69583
71460
|
import { spawnSync } from "node:child_process";
|
|
69584
71461
|
|
|
@@ -69696,15 +71573,15 @@ class ModelStream {
|
|
|
69696
71573
|
finishReason = "unknown";
|
|
69697
71574
|
usage;
|
|
69698
71575
|
add(event) {
|
|
69699
|
-
const data = streamData(event),
|
|
71576
|
+
const data = streamData(event), message2 = record(data.message), response = record(data.response);
|
|
69700
71577
|
this.chunks.push(streamText(event));
|
|
69701
71578
|
const choices = Array.isArray(data.choices) ? data.choices : [];
|
|
69702
|
-
const reason2 = choices.map((c) => record(c).finish_reason).find((r) => typeof r === "string" && r) ?? record(data.delta).stop_reason ??
|
|
71579
|
+
const reason2 = choices.map((c) => record(c).finish_reason).find((r) => typeof r === "string" && r) ?? record(data.delta).stop_reason ?? message2.stop_reason ?? data.stop_reason ?? record(response.incomplete_details).reason ?? response.status;
|
|
69703
71580
|
if (typeof reason2 === "string" && reason2)
|
|
69704
71581
|
this.finishReason = reason2;
|
|
69705
71582
|
else if (["response.completed", "response.incomplete", "response.failed"].includes(String(data.type)))
|
|
69706
71583
|
this.finishReason = String(data.type).slice("response.".length);
|
|
69707
|
-
for (const usage of [
|
|
71584
|
+
for (const usage of [message2.usage, data.usage, response.usage]) {
|
|
69708
71585
|
if (usage !== null && typeof usage === "object" && !Array.isArray(usage))
|
|
69709
71586
|
this.usage = { ...this.usage, ...record(usage) };
|
|
69710
71587
|
}
|
|
@@ -69769,8 +71646,8 @@ function isSuccess(verb, ctx) {
|
|
|
69769
71646
|
}
|
|
69770
71647
|
var past = { create: "Created", update: "Updated", delete: "Deleted", remove: "Deleted", purge: "Deleted", pause: "Paused", unpause: "Unpaused", resume: "Resumed", start: "Started", stop: "Stopped", cancel: "Cancelled", enable: "Enabled", disable: "Disabled", connect: "Connected", extend: "Extended", fork: "Forked", upload: "Uploaded", run: "Started" };
|
|
69771
71648
|
var deleted = (verb) => /^(delete|remove|purge)(-|$)/.test(verb);
|
|
69772
|
-
function width(
|
|
69773
|
-
return [...
|
|
71649
|
+
function width(text3) {
|
|
71650
|
+
return [...text3].reduce((sum, ch) => {
|
|
69774
71651
|
const cp = ch.codePointAt(0);
|
|
69775
71652
|
return sum + (/\p{Mark}/u.test(ch) || cp === 8205 ? 0 : cp >= 4352 && (cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65040 && cp <= 65135 || cp >= 65281 && cp <= 65376 || cp >= 127744) ? 2 : 1);
|
|
69776
71653
|
}, 0);
|
|
@@ -69778,13 +71655,13 @@ function width(text2) {
|
|
|
69778
71655
|
function truncate(value, size) {
|
|
69779
71656
|
if (width(value) <= size)
|
|
69780
71657
|
return value;
|
|
69781
|
-
let
|
|
71658
|
+
let text3 = "";
|
|
69782
71659
|
for (const ch of value) {
|
|
69783
|
-
if (width(
|
|
71660
|
+
if (width(text3 + ch) > size - 1)
|
|
69784
71661
|
break;
|
|
69785
|
-
|
|
71662
|
+
text3 += ch;
|
|
69786
71663
|
}
|
|
69787
|
-
return
|
|
71664
|
+
return text3 + "…";
|
|
69788
71665
|
}
|
|
69789
71666
|
function table(items, ctx, paint) {
|
|
69790
71667
|
const columns = columnsFor(items);
|
|
@@ -69817,13 +71694,13 @@ function table(items, ctx, paint) {
|
|
|
69817
71694
|
sizes[index]--;
|
|
69818
71695
|
}
|
|
69819
71696
|
const line = (row, header) => row.map((v, i) => {
|
|
69820
|
-
const
|
|
69821
|
-
let styled = header ? paint.dim(
|
|
71697
|
+
const text3 = truncate(v, sizes[i]);
|
|
71698
|
+
let styled = header ? paint.dim(text3) : text3;
|
|
69822
71699
|
if (!header && ["status", "state"].includes(columns[i])) {
|
|
69823
71700
|
const color = /^(running|active|ready|succeeded|completed|enabled)$/i.test(v) ? paint.green : /^(pending|queued|starting|creating|paused)$/i.test(v) ? paint.yellow : /^(failed|error|cancelled|expired|disabled|deleted|purging|purged|suspended)$/i.test(v) ? paint.red : (s) => s;
|
|
69824
|
-
styled = color(
|
|
71701
|
+
styled = color(text3);
|
|
69825
71702
|
}
|
|
69826
|
-
return styled + (i === row.length - 1 ? "" : " ".repeat(Math.max(0, sizes[i] - width(
|
|
71703
|
+
return styled + (i === row.length - 1 ? "" : " ".repeat(Math.max(0, sizes[i] - width(text3))));
|
|
69827
71704
|
}).join(" ");
|
|
69828
71705
|
return [line(headers, true), ...rows.map((row) => line(row, false))].join(`
|
|
69829
71706
|
`) + `
|
|
@@ -69922,9 +71799,9 @@ function renderHuman(result, ctx) {
|
|
|
69922
71799
|
}
|
|
69923
71800
|
|
|
69924
71801
|
// src/output/agent.ts
|
|
69925
|
-
function cell(
|
|
69926
|
-
const chars = [...
|
|
69927
|
-
const limited = chars.length > 500 ? chars.slice(0, 500).join("") + `…[+${chars.length - 500} chars, use --json]` :
|
|
71802
|
+
function cell(text3) {
|
|
71803
|
+
const chars = [...text3];
|
|
71804
|
+
const limited = chars.length > 500 ? chars.slice(0, 500).join("") + `…[+${chars.length - 500} chars, use --json]` : text3;
|
|
69928
71805
|
return limited.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>").replace(/\r/g, "<br>");
|
|
69929
71806
|
}
|
|
69930
71807
|
function renderAgent(result, ctx) {
|
|
@@ -69935,9 +71812,9 @@ function renderAgent(result, ctx) {
|
|
|
69935
71812
|
if (modelStream(result.op)) {
|
|
69936
71813
|
if (!result.summary)
|
|
69937
71814
|
return {};
|
|
69938
|
-
const { text:
|
|
69939
|
-
return { stdout: `${
|
|
69940
|
-
`) || !
|
|
71815
|
+
const { text: text3, finish_reason, usage } = result.summary;
|
|
71816
|
+
return { stdout: `${text3}${text3.endsWith(`
|
|
71817
|
+
`) || !text3 ? "" : `
|
|
69941
71818
|
`}finish_reason: ${finish_reason}
|
|
69942
71819
|
${usage ? `usage: ${JSON.stringify(usage)}
|
|
69943
71820
|
` : ""}` };
|
|
@@ -70156,18 +72033,18 @@ function errorInput(error, ctx) {
|
|
|
70156
72033
|
const details = candidate !== null && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : undefined;
|
|
70157
72034
|
const problem = serverProblem(Object.keys(nested).length ? nested : raw);
|
|
70158
72035
|
const serverText = (value) => typeof value === "string" && value.trim() ? value : undefined;
|
|
70159
|
-
let
|
|
70160
|
-
const prefix =
|
|
72036
|
+
let message2 = error instanceof Error ? error.message : "Unexpected error";
|
|
72037
|
+
const prefix = message2.match(/^([A-Z][A-Z0-9_]+):\s*/)?.[1];
|
|
70161
72038
|
const code = error instanceof UsageError ? error.code : businessCode(raw.code) ?? businessCode(nested.code) ?? businessCode(raw.error_code) ?? prefix ?? businessCode(sdk?.code) ?? (sdk?.status ? `HTTP_${sdk.status}` : sdk ? "API_ERROR" : "RUNTIME_ERROR");
|
|
70162
72039
|
let stripped = false;
|
|
70163
|
-
while (
|
|
70164
|
-
|
|
72040
|
+
while (message2.startsWith(`${code}:`)) {
|
|
72041
|
+
message2 = message2.slice(code.length + 1).trimStart();
|
|
70165
72042
|
stripped = true;
|
|
70166
72043
|
}
|
|
70167
72044
|
if (stripped)
|
|
70168
|
-
|
|
72045
|
+
message2 = `${humanize(code)}${message2 ? `: ${message2}` : ""}`;
|
|
70169
72046
|
const status = sdk?.status, request_id = sdk?.requestId;
|
|
70170
|
-
|
|
72047
|
+
message2 = serverText(problem?.detail) ?? serverText(problem?.title) ?? message2;
|
|
70171
72048
|
const authFailure = status === 401 || ["NOT_LOGGED_IN", "UNAUTHENTICATED", "TOKEN_REVOKED", "LOGIN_FAILED", "MANAGED_LOGIN_EXPIRED"].includes(code);
|
|
70172
72049
|
const source = ctx.credentialSource ?? "login";
|
|
70173
72050
|
let hint3 = genericHint;
|
|
@@ -70185,19 +72062,19 @@ function errorInput(error, ctx) {
|
|
|
70185
72062
|
hint3 = "Rate limited; retry later.";
|
|
70186
72063
|
else if (status !== undefined && status >= 500)
|
|
70187
72064
|
hint3 = `Server error; retry later.${request_id ? ` Request id: ${request_id}.` : ""}`;
|
|
70188
|
-
return { kind: "error", code, message, hint: hint3, ...details !== undefined ? { details } : {}, ...problem !== undefined ? { problem } : {}, env: ctx.env, ...authFailure ? { credential_source: source } : {}, ...status !== undefined ? { status } : {}, ...request_id ? { request_id } : {} };
|
|
72065
|
+
return { kind: "error", code, message: message2, hint: hint3, ...details !== undefined ? { details } : {}, ...problem !== undefined ? { problem } : {}, env: ctx.env, ...authFailure ? { credential_source: source } : {}, ...status !== undefined ? { status } : {}, ...request_id ? { request_id } : {} };
|
|
70189
72066
|
}
|
|
70190
72067
|
|
|
70191
72068
|
// src/output/progress.ts
|
|
70192
|
-
function startProgress(ctx, write = (
|
|
72069
|
+
function startProgress(ctx, write = (text3) => writeOutput({ stderr: text3 })) {
|
|
70193
72070
|
if (ctx.mode !== "human" || !ctx.stderrIsTTY)
|
|
70194
72071
|
return () => {};
|
|
70195
72072
|
let interval;
|
|
70196
|
-
let shown = false,
|
|
72073
|
+
let shown = false, frame2 = 0;
|
|
70197
72074
|
const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
|
|
70198
72075
|
const tick = () => {
|
|
70199
72076
|
shown = true;
|
|
70200
|
-
write(`\r${frames[
|
|
72077
|
+
write(`\r${frames[frame2++ % frames.length]} Loading…`);
|
|
70201
72078
|
};
|
|
70202
72079
|
const timer = setTimeout(() => {
|
|
70203
72080
|
tick();
|
|
@@ -70215,7 +72092,7 @@ function startProgress(ctx, write = (text2) => writeOutput({ stderr: text2 })) {
|
|
|
70215
72092
|
}
|
|
70216
72093
|
|
|
70217
72094
|
// src/main.ts
|
|
70218
|
-
var version = "0.3.0-dev.
|
|
72095
|
+
var version = "0.3.0-dev.0d6e54c";
|
|
70219
72096
|
var commands = commandTree(operations);
|
|
70220
72097
|
var manual = [...workflows.map((w) => w.words), [API_WORD]];
|
|
70221
72098
|
function route(argv) {
|
|
@@ -70394,6 +72271,21 @@ var appOptions = {
|
|
|
70394
72271
|
{ name: "report", type: "boolean", description: "Post this checkout's scan to the platform, so archiving a flag is refused while code still names it (ADR-125 §4)." },
|
|
70395
72272
|
{ name: "project", type: "string", description: "With --report: the DevOps project id (dvp_…) whose flags the scan is reported into. Required." }
|
|
70396
72273
|
],
|
|
72274
|
+
"agent memory": [
|
|
72275
|
+
{ name: "hook", type: "string", description: "Run as a Claude Code hook (SessionStart or UserPromptSubmit): read the hook input on stdin, print the hook JSON or nothing, always exit 0." }
|
|
72276
|
+
],
|
|
72277
|
+
"agent recall": [
|
|
72278
|
+
{ name: "words", type: "string", repeated: true, description: "Distinctive words to recall by, comma-separated or repeated." },
|
|
72279
|
+
{ name: "handles", type: "string", repeated: true, description: "Entry handles or ids from memory to recall, comma-separated or repeated." }
|
|
72280
|
+
],
|
|
72281
|
+
"agent remember": [
|
|
72282
|
+
{ name: "text", type: "string", description: "The experience, in your own words: what happened, who, what was decided and why, what is still open." },
|
|
72283
|
+
{ name: "about", type: "string", repeated: true, description: "Ids of entities it is about, comma-separated or repeated." }
|
|
72284
|
+
],
|
|
72285
|
+
"agent events wait": [
|
|
72286
|
+
{ name: "timeout", type: "string", description: "Give up after this many seconds, print that nothing arrived and exit 0 (default: wait until a letter arrives)." },
|
|
72287
|
+
{ name: "session", type: "string", description: "The Claude Code session this waiter wakes: its announced letters and pid file are kept per session, and a second waiter for the same session exits at once (default: one waiter per agent)." }
|
|
72288
|
+
],
|
|
70397
72289
|
"canvas import": [
|
|
70398
72290
|
{ name: "name", type: "string", description: "Name for the new canvas (default: the file name without .pen)." },
|
|
70399
72291
|
{ name: "canvas", type: "string", description: "Import into this existing canvas instead of a new one. Whole-canvas replacement: it clears what is already there and requires --yes." },
|
|
@@ -70412,15 +72304,15 @@ function flagPortsFor(ports, context, emit, connect) {
|
|
|
70412
72304
|
return {
|
|
70413
72305
|
mode: context.mode,
|
|
70414
72306
|
emit,
|
|
70415
|
-
human: (
|
|
72307
|
+
human: (text3) => {
|
|
70416
72308
|
if (context.mode === "human")
|
|
70417
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72309
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70418
72310
|
},
|
|
70419
72311
|
cwd: ports.cwd,
|
|
70420
72312
|
readFile: ports.readFile,
|
|
70421
72313
|
git: async (args) => (await ports.spawnCapture("git", [...args], { cwd: ports.cwd })).output,
|
|
70422
72314
|
client: connect,
|
|
70423
|
-
writeFile: (path,
|
|
72315
|
+
writeFile: (path, text3) => writeFile5(path, text3, "utf8"),
|
|
70424
72316
|
mkdir: async (path) => {
|
|
70425
72317
|
await mkdir4(path, { recursive: true });
|
|
70426
72318
|
},
|
|
@@ -70444,9 +72336,9 @@ function toolPortsFor(ports, context, emit) {
|
|
|
70444
72336
|
return {
|
|
70445
72337
|
mode: context.mode,
|
|
70446
72338
|
emit,
|
|
70447
|
-
human: (
|
|
72339
|
+
human: (text3) => {
|
|
70448
72340
|
if (context.mode === "human")
|
|
70449
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72341
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70450
72342
|
},
|
|
70451
72343
|
cwd: ports.cwd,
|
|
70452
72344
|
readFile: ports.readFile,
|
|
@@ -70486,7 +72378,7 @@ async function main3(argv, injected = {}) {
|
|
|
70486
72378
|
columns: ports.columns,
|
|
70487
72379
|
now: ports.now(),
|
|
70488
72380
|
envVars: { NO_COLOR: ports.env.NO_COLOR, FORCE_COLOR: ports.env.FORCE_COLOR, TERM: ports.env.TERM },
|
|
70489
|
-
env: ports.env.PRAXIS_ENV ??
|
|
72381
|
+
env: ports.env.PRAXIS_ENV ?? DEFAULT_ENV
|
|
70490
72382
|
};
|
|
70491
72383
|
let stopProgress = () => {};
|
|
70492
72384
|
let quiet = false;
|
|
@@ -70756,9 +72648,9 @@ Examples:
|
|
|
70756
72648
|
},
|
|
70757
72649
|
mode: ctx.mode,
|
|
70758
72650
|
emit,
|
|
70759
|
-
human: (
|
|
72651
|
+
human: (text3) => {
|
|
70760
72652
|
if (ctx.mode === "human")
|
|
70761
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72653
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70762
72654
|
},
|
|
70763
72655
|
cwd: ports.cwd
|
|
70764
72656
|
});
|
|
@@ -70785,14 +72677,14 @@ Examples:
|
|
|
70785
72677
|
}, {
|
|
70786
72678
|
mode: ctx.mode,
|
|
70787
72679
|
emit,
|
|
70788
|
-
human: (
|
|
72680
|
+
human: (text3) => {
|
|
70789
72681
|
if (ctx.mode === "human")
|
|
70790
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72682
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70791
72683
|
},
|
|
70792
72684
|
engine: codeRefactorEngine(),
|
|
70793
72685
|
hasFile: (path2) => existsSync4(path2),
|
|
70794
72686
|
readFile: ports.readFile,
|
|
70795
|
-
writeFile: (path2,
|
|
72687
|
+
writeFile: (path2, text3) => writeFile5(path2, text3, "utf8"),
|
|
70796
72688
|
mkdir: async (path2) => {
|
|
70797
72689
|
await mkdir4(path2, { recursive: true });
|
|
70798
72690
|
},
|
|
@@ -70809,9 +72701,9 @@ Examples:
|
|
|
70809
72701
|
const shellPorts = {
|
|
70810
72702
|
mode: ctx.mode,
|
|
70811
72703
|
emit,
|
|
70812
|
-
human: (
|
|
72704
|
+
human: (text3) => {
|
|
70813
72705
|
if (ctx.mode === "human")
|
|
70814
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72706
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70815
72707
|
},
|
|
70816
72708
|
engine: await repositoryEngine(name, () => localEngine(ports.cwd)),
|
|
70817
72709
|
...localFilePorts(ports.cwd)
|
|
@@ -70824,9 +72716,9 @@ Examples:
|
|
|
70824
72716
|
const testPorts = {
|
|
70825
72717
|
mode: ctx.mode,
|
|
70826
72718
|
emit,
|
|
70827
|
-
human: (
|
|
72719
|
+
human: (text3) => {
|
|
70828
72720
|
if (ctx.mode === "human")
|
|
70829
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72721
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70830
72722
|
},
|
|
70831
72723
|
engine: await repositoryEngine(name, () => localEngine(ports.cwd)),
|
|
70832
72724
|
checkout: await localCheckout(ports.cwd, (cmd, args, options) => ports.spawnCapture(cmd, args, options))
|
|
@@ -70835,9 +72727,9 @@ Examples:
|
|
|
70835
72727
|
return await devopsTestReport({ path: parsed.positional[0], id: parsed.flags.id?.[0], upload: Boolean(parsed.flags.upload), project: parsed.flags.project?.[0] }, testPorts, {
|
|
70836
72728
|
mode: ctx.mode,
|
|
70837
72729
|
emit,
|
|
70838
|
-
human: (
|
|
72730
|
+
human: (text3) => {
|
|
70839
72731
|
if (ctx.mode === "human")
|
|
70840
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72732
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70841
72733
|
},
|
|
70842
72734
|
root: async () => await checkoutRoot(ports.cwd, ports.readFile),
|
|
70843
72735
|
readFile: ports.readFile,
|
|
@@ -70867,9 +72759,9 @@ Examples:
|
|
|
70867
72759
|
git: (args) => ports.spawnCapture("git", args, { cwd: ports.cwd }),
|
|
70868
72760
|
mode: ctx.mode,
|
|
70869
72761
|
emit,
|
|
70870
|
-
human: (
|
|
72762
|
+
human: (text3) => {
|
|
70871
72763
|
if (ctx.mode === "human")
|
|
70872
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72764
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70873
72765
|
}
|
|
70874
72766
|
});
|
|
70875
72767
|
}
|
|
@@ -70919,9 +72811,9 @@ Examples:
|
|
|
70919
72811
|
emit({ kind: "object", data: await auth.switchOrganization(parsed.positional[0]) });
|
|
70920
72812
|
break;
|
|
70921
72813
|
case "app create": {
|
|
70922
|
-
const appPorts = { ...ports, mode: ctx.mode, emit, human: (
|
|
72814
|
+
const appPorts = { ...ports, mode: ctx.mode, emit, human: (text3) => {
|
|
70923
72815
|
if (ctx.mode === "human")
|
|
70924
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72816
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70925
72817
|
}, random: randomSecret };
|
|
70926
72818
|
await appCreate({ name: parsed.positional[0], dir: parsed.flags.dir?.[0], template: parsed.flags.template?.[0], install: !parsed.flags["no-install"] }, config.env, appPorts);
|
|
70927
72819
|
break;
|
|
@@ -70950,13 +72842,220 @@ Examples:
|
|
|
70950
72842
|
wait: ports.wait,
|
|
70951
72843
|
mode: ctx.mode,
|
|
70952
72844
|
emit,
|
|
70953
|
-
human: (
|
|
72845
|
+
human: (text3) => {
|
|
70954
72846
|
if (ctx.mode === "human")
|
|
70955
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
72847
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
70956
72848
|
},
|
|
70957
72849
|
cwd: ports.cwd
|
|
70958
72850
|
});
|
|
70959
72851
|
}
|
|
72852
|
+
case "agent events channel": {
|
|
72853
|
+
const agent = assumeAgentOf(ports.env);
|
|
72854
|
+
const headers = async () => {
|
|
72855
|
+
const credential = await auth.get(org);
|
|
72856
|
+
return { Authorization: `Bearer ${credential.token}`, ...credential.source === "api-key" ? { "X-API-Key": credential.token } : {} };
|
|
72857
|
+
};
|
|
72858
|
+
const failure2 = (status, body) => `HTTP ${status}${body?.error?.code ? ` ${body.error.code}` : ""}${body?.error?.message ? `: ${String(redact(body.error.message, secrets))}` : ""}`;
|
|
72859
|
+
process.stdin.setEncoding("utf8");
|
|
72860
|
+
return await runChannel({
|
|
72861
|
+
agent,
|
|
72862
|
+
input: process.stdin,
|
|
72863
|
+
send: (frame2) => {
|
|
72864
|
+
process.stdout.write(JSON.stringify(frame2) + `
|
|
72865
|
+
`);
|
|
72866
|
+
},
|
|
72867
|
+
fetchLetters: async () => {
|
|
72868
|
+
const response = await wireFetch(inboxLettersUrl(config.apiUrl, agent), { headers: await headers(), signal: AbortSignal.timeout(30000), redirect: "error" });
|
|
72869
|
+
const body = await response.json().catch(() => null);
|
|
72870
|
+
if (!response.ok)
|
|
72871
|
+
throw new Error(failure2(response.status, body));
|
|
72872
|
+
return lettersOf(body);
|
|
72873
|
+
},
|
|
72874
|
+
openStream: async (signal, lastEventId) => {
|
|
72875
|
+
const response = await wireFetch(eventsStreamUrl(config.apiUrl, agent), { headers: streamHeaders(await headers(), lastEventId), signal, redirect: "error" });
|
|
72876
|
+
if (!response.ok || !response.body) {
|
|
72877
|
+
const body = await response.json().catch(() => null);
|
|
72878
|
+
return { status: response.status, reason: failure2(response.status, body) };
|
|
72879
|
+
}
|
|
72880
|
+
return { status: response.status, chunks: response.body.pipeThrough(new TextDecoderStream) };
|
|
72881
|
+
},
|
|
72882
|
+
sleep: (ms, signal) => new Promise((resolve12) => {
|
|
72883
|
+
const timer = setTimeout(resolve12, ms);
|
|
72884
|
+
signal.addEventListener("abort", () => {
|
|
72885
|
+
clearTimeout(timer);
|
|
72886
|
+
resolve12();
|
|
72887
|
+
}, { once: true });
|
|
72888
|
+
}),
|
|
72889
|
+
log: (line) => {
|
|
72890
|
+
process.stderr.write(String(redact(line, secrets)) + `
|
|
72891
|
+
`);
|
|
72892
|
+
}
|
|
72893
|
+
});
|
|
72894
|
+
}
|
|
72895
|
+
case "agent memory":
|
|
72896
|
+
case "agent recall":
|
|
72897
|
+
case "agent remember": {
|
|
72898
|
+
const agent = assumeAgentOf(ports.env);
|
|
72899
|
+
const mcpPorts = {
|
|
72900
|
+
fetch: (url2, init) => wireFetch(url2, init),
|
|
72901
|
+
headers: async () => {
|
|
72902
|
+
const credential = await auth.get(org);
|
|
72903
|
+
return { Authorization: `Bearer ${credential.token}`, ...credential.source === "api-key" ? { "X-API-Key": credential.token } : {} };
|
|
72904
|
+
}
|
|
72905
|
+
};
|
|
72906
|
+
const url = mcpUrl(config.apiUrl, agent);
|
|
72907
|
+
const hook = parsed.flags.hook?.[0];
|
|
72908
|
+
if (name === "agent memory" && hook !== undefined) {
|
|
72909
|
+
if (hook !== "SessionStart" && hook !== "UserPromptSubmit")
|
|
72910
|
+
throw new UsageError(`--hook takes SessionStart or UserPromptSubmit, not ${hook}`, "Example: praxis agent memory --hook SessionStart");
|
|
72911
|
+
process.stdin.setEncoding("utf8");
|
|
72912
|
+
let raw = "";
|
|
72913
|
+
if (!process.stdin.isTTY)
|
|
72914
|
+
for await (const chunk of process.stdin)
|
|
72915
|
+
raw += chunk;
|
|
72916
|
+
const input = hookInputOf(raw);
|
|
72917
|
+
const seenDir = join12(ports.env.HOME || homedir3(), ".praxis", "cli", "memory-seen");
|
|
72918
|
+
const out = await runMemoryHook(hook, input, {
|
|
72919
|
+
...mcpPorts,
|
|
72920
|
+
url,
|
|
72921
|
+
timeoutMs: 25000,
|
|
72922
|
+
readSeen: async (id) => JSON.parse(await readFile7(join12(seenDir, `${id}.json`), "utf8")),
|
|
72923
|
+
writeSeen: async (id, paragraphs) => {
|
|
72924
|
+
await mkdir4(seenDir, { recursive: true, mode: 448 });
|
|
72925
|
+
await writeFile5(join12(seenDir, `${id}.json`), JSON.stringify(paragraphs), { mode: 384 });
|
|
72926
|
+
}
|
|
72927
|
+
});
|
|
72928
|
+
if (out !== null)
|
|
72929
|
+
process.stdout.write(out + `
|
|
72930
|
+
`);
|
|
72931
|
+
return 0;
|
|
72932
|
+
}
|
|
72933
|
+
const list = (flag) => (parsed.flags[flag] ?? []).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
|
|
72934
|
+
const args = name === "agent recall" ? { ...list("handles").length ? { handles: list("handles") } : {}, ...list("words").length ? { words: list("words") } : {} } : name === "agent remember" ? { text: parsed.flags.text?.[0] ?? "", ...list("about").length ? { about: list("about") } : {} } : {};
|
|
72935
|
+
if (name === "agent remember" && String(args.text).trim() === "")
|
|
72936
|
+
throw new UsageError("--text is required", 'Example: praxis agent remember --text "今天定了……"');
|
|
72937
|
+
const tool = name === "agent memory" ? MEMORY_TOOL : name === "agent recall" ? RECALL_TOOL : REMEMBER_TOOL;
|
|
72938
|
+
const text3 = memoryBodyOf(await callAgentTool(mcpPorts, url, tool, args, AbortSignal.timeout(60000)));
|
|
72939
|
+
process.stdout.write(text3 + `
|
|
72940
|
+
`);
|
|
72941
|
+
return 0;
|
|
72942
|
+
}
|
|
72943
|
+
case "agent events wait": {
|
|
72944
|
+
const agent = assumeAgentOf(ports.env);
|
|
72945
|
+
const timeoutMs = (() => {
|
|
72946
|
+
try {
|
|
72947
|
+
return timeoutMsOf(parsed.flags.timeout?.[0]);
|
|
72948
|
+
} catch (error) {
|
|
72949
|
+
throw new UsageError(error.message, "Example: praxis agent events wait --timeout 3600");
|
|
72950
|
+
}
|
|
72951
|
+
})();
|
|
72952
|
+
const headers = async () => {
|
|
72953
|
+
const credential = await auth.get(org);
|
|
72954
|
+
return { Authorization: `Bearer ${credential.token}`, ...credential.source === "api-key" ? { "X-API-Key": credential.token } : {} };
|
|
72955
|
+
};
|
|
72956
|
+
const failure2 = (status, body) => `HTTP ${status}${body?.error?.code ? ` ${body.error.code}` : ""}${body?.error?.message ? `: ${String(redact(body.error.message, secrets))}` : ""}`;
|
|
72957
|
+
const session = (() => {
|
|
72958
|
+
try {
|
|
72959
|
+
return sessionOf(parsed.flags.session?.[0]);
|
|
72960
|
+
} catch (error) {
|
|
72961
|
+
throw new UsageError(error.message, "Example: praxis agent events wait --session 0f6c…");
|
|
72962
|
+
}
|
|
72963
|
+
})();
|
|
72964
|
+
const key = waitKeyOf(config.env, agent, session);
|
|
72965
|
+
const waitDir = join12(ports.env.HOME || homedir3(), ".praxis", "cli", "events-wait");
|
|
72966
|
+
const statePath = join12(waitDir, `${key}.json`);
|
|
72967
|
+
const pidPath = join12(waitDir, `${key}.pid`);
|
|
72968
|
+
await mkdir4(waitDir, { recursive: true, mode: 448 });
|
|
72969
|
+
const holder = await acquireWaitLock({
|
|
72970
|
+
self: process.pid,
|
|
72971
|
+
readPid: () => readFile7(pidPath, "utf8").catch(() => null),
|
|
72972
|
+
createPid: (text3) => writeFile5(pidPath, text3, { mode: 384, flag: "wx" }).then(() => true, () => false),
|
|
72973
|
+
replacePid: (text3) => writeFile5(pidPath, text3, { mode: 384 }),
|
|
72974
|
+
probe: async (pid) => {
|
|
72975
|
+
try {
|
|
72976
|
+
process.kill(pid, 0);
|
|
72977
|
+
} catch (error) {
|
|
72978
|
+
if (error.code !== "EPERM")
|
|
72979
|
+
return { alive: false };
|
|
72980
|
+
}
|
|
72981
|
+
const ps = spawnSync("ps", ["-o", "ppid=,command=", "-p", String(pid)], { encoding: "utf8" });
|
|
72982
|
+
const line = ps.stdout?.trim() ?? "";
|
|
72983
|
+
const match = /^(\d+)\s+(.*)$/.exec(line);
|
|
72984
|
+
return match ? { alive: true, ppid: Number(match[1]), command: match[2] } : { alive: false };
|
|
72985
|
+
},
|
|
72986
|
+
terminate: (pid) => {
|
|
72987
|
+
try {
|
|
72988
|
+
process.kill(pid, "SIGTERM");
|
|
72989
|
+
} catch {}
|
|
72990
|
+
}
|
|
72991
|
+
});
|
|
72992
|
+
if (holder !== null) {
|
|
72993
|
+
process.stdout.write(alreadyWaitingNotice(holder) + `
|
|
72994
|
+
`);
|
|
72995
|
+
return 0;
|
|
72996
|
+
}
|
|
72997
|
+
const release = () => {
|
|
72998
|
+
try {
|
|
72999
|
+
if (pidOf(readFileSync3(pidPath, "utf8")) === process.pid)
|
|
73000
|
+
unlinkSync(pidPath);
|
|
73001
|
+
} catch {}
|
|
73002
|
+
};
|
|
73003
|
+
const onSignal = (signal) => {
|
|
73004
|
+
release();
|
|
73005
|
+
process.exit(signal === "SIGINT" ? 130 : 143);
|
|
73006
|
+
};
|
|
73007
|
+
for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
|
|
73008
|
+
process.once(signal, onSignal);
|
|
73009
|
+
try {
|
|
73010
|
+
return await runEventsWait({
|
|
73011
|
+
agent,
|
|
73012
|
+
timeoutMs,
|
|
73013
|
+
fetchLetters: async () => {
|
|
73014
|
+
const response = await wireFetch(inboxLettersUrl(config.apiUrl, agent), { headers: await headers(), signal: AbortSignal.timeout(30000), redirect: "error" });
|
|
73015
|
+
const body = await response.json().catch(() => null);
|
|
73016
|
+
if (!response.ok)
|
|
73017
|
+
throw new Error(failure2(response.status, body));
|
|
73018
|
+
return lettersOf(body);
|
|
73019
|
+
},
|
|
73020
|
+
openStream: async (signal, lastEventId) => {
|
|
73021
|
+
const response = await wireFetch(eventsStreamUrl(config.apiUrl, agent), {
|
|
73022
|
+
headers: streamHeaders(await headers(), lastEventId),
|
|
73023
|
+
signal,
|
|
73024
|
+
redirect: "error"
|
|
73025
|
+
});
|
|
73026
|
+
if (!response.ok || !response.body) {
|
|
73027
|
+
const body = await response.json().catch(() => null);
|
|
73028
|
+
return { status: response.status, reason: failure2(response.status, body) };
|
|
73029
|
+
}
|
|
73030
|
+
return { status: response.status, chunks: response.body.pipeThrough(new TextDecoderStream) };
|
|
73031
|
+
},
|
|
73032
|
+
readState: async () => waitStateOf(await readFile7(statePath, "utf8").catch(() => null)),
|
|
73033
|
+
writeState: async (next) => {
|
|
73034
|
+
await mkdir4(dirname10(statePath), { recursive: true, mode: 448 });
|
|
73035
|
+
await writeFile5(statePath, waitStateText(next), { mode: 384 });
|
|
73036
|
+
},
|
|
73037
|
+
print: (line) => {
|
|
73038
|
+
process.stdout.write(line + `
|
|
73039
|
+
`);
|
|
73040
|
+
},
|
|
73041
|
+
log: (line) => {
|
|
73042
|
+
process.stderr.write(String(redact(line, secrets)) + `
|
|
73043
|
+
`);
|
|
73044
|
+
},
|
|
73045
|
+
sleep: (ms, signal) => new Promise((resolve12) => {
|
|
73046
|
+
const timer = setTimeout(resolve12, ms);
|
|
73047
|
+
signal.addEventListener("abort", () => {
|
|
73048
|
+
clearTimeout(timer);
|
|
73049
|
+
resolve12();
|
|
73050
|
+
}, { once: true });
|
|
73051
|
+
})
|
|
73052
|
+
});
|
|
73053
|
+
} finally {
|
|
73054
|
+
release();
|
|
73055
|
+
for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
|
|
73056
|
+
process.removeListener(signal, onSignal);
|
|
73057
|
+
}
|
|
73058
|
+
}
|
|
70960
73059
|
case "canvas import": {
|
|
70961
73060
|
const authorize = async () => {
|
|
70962
73061
|
const credential = await auth.get(org);
|
|
@@ -70998,7 +73097,7 @@ Examples:
|
|
|
70998
73097
|
file: parsed.positional[0],
|
|
70999
73098
|
name: parsed.flags.name?.[0],
|
|
71000
73099
|
canvas: parsed.flags.canvas?.[0],
|
|
71001
|
-
frames: typeof parsed.flags.frames?.[0] === "string" ? parsed.flags.frames[0].split(",").map((
|
|
73100
|
+
frames: typeof parsed.flags.frames?.[0] === "string" ? parsed.flags.frames[0].split(",").map((frame2) => frame2.trim()).filter(Boolean) : undefined,
|
|
71002
73101
|
imageRoots: parsed.flags["image-root"],
|
|
71003
73102
|
dryRun: Boolean(parsed.flags["dry-run"]?.[0]),
|
|
71004
73103
|
yes: Boolean(flags.yes)
|
|
@@ -71012,9 +73111,9 @@ Examples:
|
|
|
71012
73111
|
cwd: ports.cwd,
|
|
71013
73112
|
rpc,
|
|
71014
73113
|
upload,
|
|
71015
|
-
human: (
|
|
73114
|
+
human: (text3) => {
|
|
71016
73115
|
if (ctx.mode === "human")
|
|
71017
|
-
emit({ kind: "message", channel: "stdout", text:
|
|
73116
|
+
emit({ kind: "message", channel: "stdout", text: text3 });
|
|
71018
73117
|
}
|
|
71019
73118
|
});
|
|
71020
73119
|
}
|