needle-cloud 2.4.5 → 2.4.6

package/dist/cli.esm.js

@@ -1 +1 @@
-import"node-fetch";import"@web-std/file";import"node:crypto";export{p as program}from"./cli-5251dd32.js";import"fs";import"dotenv";import"ora";import"commander";import"open";import"crypto";import"buffer";import"path";import"node:fs";import"node:fs/promises";import"node:os";import"node:path";import"util";import"stream";import"http";import"https";import"url";import"assert";import"tty";import"os";import"zlib";import"events";import"node:readline/promises";import"@logto/node";import"node:readline";import"node:stream";import"node:zlib";import"express";import"ws";import"child_process";import"minimatch";import"body-parser";import"node:child_process";
+import"node-fetch";import"@web-std/file";import"node:crypto";export{p as program}from"./cli-619611b8.js";import"fs";import"dotenv";import"ora";import"commander";import"open";import"crypto";import"buffer";import"path";import"node:fs";import"node:fs/promises";import"node:os";import"node:path";import"util";import"stream";import"http";import"https";import"url";import"net";import"tls";import"assert";import"tty";import"os";import"events";import"http2";import"zlib";import"node:readline/promises";import"@logto/node";import"node:readline";import"node:stream";import"node:zlib";import"express";import"ws";import"child_process";import"minimatch";import"body-parser";import"node:child_process";

package/dist/cli.send-logs.discovery-5657815c.js

@@ -0,0 +1 @@
+import{existsSync as t,readdirSync as o,statSync as r}from"node:fs";import{dirname as i,join as e}from"node:path";import{g as n}from"./cli-619611b8.js";import"node-fetch";import"@web-std/file";import"node:crypto";import"commander";import"fs";import"open";import"crypto";import"buffer";import"path";import"ora";import"node:fs/promises";import"node:os";import"util";import"stream";import"http";import"https";import"url";import"net";import"tls";import"assert";import"tty";import"os";import"events";import"http2";import"zlib";import"node:readline/promises";import"dotenv";import"@logto/node";import"node:readline";import"node:stream";import"node:zlib";import"express";import"ws";import"child_process";import"minimatch";import"body-parser";import"node:child_process";function p(){var p;let m;try{m=n()}catch{return null}const s=null==(p=m)||null==(p=p.entries)?void 0:p[0];if(!s)return null;if(!s.log_location)return null;if("unity"!==s.editor&&"blender"!==s.editor)return null;if(!t(s.log_location))return null;const l=s.log_location,c=function(t,i){const n=new Set([i]);try{for(const i of o(t)){if(!i.toLowerCase().endsWith(".log"))continue;const o=e(t,i);try{if(!r(o).isFile())continue}catch{continue}n.add(o)}}catch{}return[...n]}(i(l),l);return{editor:s.editor,path:l,paths:c}}export{p as findActiveEditorLog};

package/dist/index.d.ts

@@ -90,6 +90,10 @@ declare namespace Auth {
      * Request an access token for the configured resource
      * @param {string | undefined | null} [org_id] - The organization ID (optional). If none is provided the user access token will be requested.
      * @returns {Promise<string>}
+     *
+     * Deduplicated per org: every caller that needs a token used to ask
+     * independently, so one page load fired eight identical requests. Concurrent
+     * callers now share one; see _requestAccessToken.
      */
     function requestAccessToken(org_id?: string | undefined | null): Promise<string>;
     /**
@@ -170,26 +174,65 @@ type RecentChatsResponse$1 = {
 }
 
 
-/** Context block sent by the client (e.g. page metadata, scene hierarchy). */
-type ClientContext = {
-    type: "text",
-    text: string,
+/**
+ * How much of an image the model is asked to look at. `low` costs a fraction of
+ * `high` and answers most of what a picture is sent for ("is the object in
+ * frame?", "is the scene dark?"); choose `high` when it has to read text in the
+ * image. Defaults to `low`.
+ */
+type ImageDetail = "high" | "low"
+
+/** An image sent to the model. `url` is an http(s) url or a `data:image/...` url. */
+type ClientImage = {
+    type: "image",
+    url: string,
+    detail?: ImageDetail,
 }
 
+/** Context block sent by the client (e.g. page metadata, scene hierarchy, a screenshot). */
+type ClientContext =
+    | { type: "text", text: string }
+    | ClientImage
+
 
 type ChatMessageToolCall = {
     name: string,
+    /** Server-provided pretty label for the tool, when the tool author set one
+     *  (streamed on the tool_call event). The UI prefers this over title-casing
+     *  the raw `name`. */
+    display_name?: string | null,
     args: Record<string, any>,
     result_length?: number,
     duration_ms?: number,
 }
 
+/**
+ * An image belonging to a chat message — a screenshot the AI took, a render.
+ *
+ * `url` is a stable, token-signed route on the API (not a presigned storage
+ * url): it can be rendered directly, it does not expire between page loads, and
+ * it stops resolving as soon as the chat is deleted.
+ */
+type ChatMessageAttachment = {
+    kind: "image",
+    url: string,
+    mime?: string,
+    width?: number,
+    height?: number,
+    /** How much of it the model was asked to look at. */
+    detail?: ImageDetail,
+    /** What produced it, e.g. the name of the tool that returned it. */
+    source?: string,
+}
+
 type ChatMessage = {
     created_at: string,
     id: string,
     role: "assistant" | "tool" | "user",
     content: string,
     tool_calls?: ChatMessageToolCall[],
+    /** Images belonging to this message. Absent on the vast majority of messages. */
+    attachments?: ChatMessageAttachment[],
     metadata?: {
         tokens?: { input: number, output: number },
         model?: string,
@@ -274,11 +317,18 @@ type ChatStreamEvent = { /** SSE event id for position tracking. */ id?: number
     /** Server-assigned message ID for the AI response. */
     | { type: "message_id", message_id: string }
     /** The AI invoked a tool. Use for UI indicators (e.g. "Running get_screenshot..."). */
-    | { type: "tool_call", name: string, args: Record<string, any> }
+    | { type: "tool_call", name: string, display_name?: string | null, args: Record<string, any> }
     /** A tool finished executing. The AI will continue generating with the result. */
     | { type: "tool_result", name: string }
     /** An error occurred. Display `message` to the user. */
     | { type: "error", message: string }
+    /**
+     * A non-fatal problem the USER should see, rendered as its own line rather
+     * than folded into the answer. First case: a step whose model cannot view
+     * images, so the picture was left out of the request instead of failing the
+     * whole turn.
+     */
+    | { type: "notice", message: string }
     /** Generation was interrupted by the user (via `interruptChat()`). */
     | { type: "stopped" }
     /** Informational status update (e.g. "Searching documentation..."). */
@@ -337,6 +387,36 @@ type ToolDefinition$1 = {
     inputSchema: Record<string, any>,
 }
 
+/**
+ * Which chat a tool request came from, passed to `onToolRequest`.
+ *
+ * One tool connection serves every chat you have open, so a client running more
+ * than one conversation needs this to attach the result to the right one.
+ */
+type ToolRequestMeta = {
+    /** The chat this request belongs to; `null` if the server did not identify one. */
+    chatId: string | null,
+    /** Id of this request, matching the result sent back for it. */
+    requestId: string,
+}
+
+/**
+ * What a tool hands back.
+ *
+ * `images` is the way to return a PICTURE — a screenshot, a render, a chart —
+ * instead of describing it. They reach the model as image parts on a following
+ * user turn (a tool message itself can only carry text), so the model sees them
+ * rather than being handed a base64 string it cannot read.
+ *
+ * Keep them few and small: an image is a payload, and `detail: "low"` is both
+ * the default and usually enough.
+ */
+type ToolRequestOutcome = {
+    result?: any,
+    error?: string,
+    images?: Array<{ url: string, detail?: ImageDetail }>,
+}
+
 
 // ─── ChatSession Types ──────────────────────────────────────────────
 
@@ -357,8 +437,9 @@ type ChatSessionOptions$1 = {
      * Called when the server requests tool execution.
      * Return `{ result: ... }` on success or `{ error: "..." }` on failure.
      * Required if `tools` is non-empty.
+     * `meta.chatId` says which chat asked — a session can drive several.
      */
-    onToolRequest?: (name: string, args: Record<string, any>) => Promise<{ result?: any, error?: string }>,
+    onToolRequest?: (name: string, args: Record<string, any>, meta: ToolRequestMeta) => Promise<ToolRequestOutcome>,
     /**
      * How long (ms) to wait for the WebSocket to connect and register tools
      * before `ready` rejects. Defaults to 5000. Set to 0 to skip WS entirely.
@@ -1204,6 +1285,13 @@ type ContentListItem = {
     content_type: ContentType | null;
     /** Available content formats for this content item (e.g. ["glb", "textures"]) */
     content_formats: ContentFormat[];
+    /** Page for editing this item in the cloud UI. Present for everything the
+     *  caller can see through this endpoint, since it is already scoped to their
+     *  org. Null only when the server has no configured frontend origin. */
+    edit_url?: string | null;
+    /** Standalone viewer page. Null for deployments (they ARE a website — use
+     *  `url`) and for items with no artifact to view yet. */
+    view_url?: string | null;
     /** Number of top-level versions (matches the versions[] array in the detail response) */
     version_count: number;
     /** Whether the content is password-protected (requires commercial license) */
@@ -1403,6 +1491,323 @@ declare function getContent(identifier: string, opts?: {
     authToken?: string;
 }): Promise<GetContentDetailResponse>;
 
+/**
+ * @internal Needle editor cloud projects — versioned revisions of OPAQUE
+ * project documents (needle-cloud plans/cloud-projects-api.md). Editor-only,
+ * NO stability guarantee, deliberately not in the public OpenAPI docs.
+ *
+ * The server never parses a document: it stores blobs plus a revision graph.
+ * These types ARE the wire contract the editor's IProjectRemote adapter
+ * aligns to.
+ */
+
+/** derived server-side from timestamps; deleted outranks archived.
+ * "deleted" lists the BIN (bounded to the restore window). */
+type ProjectState = "active" | "archived" | "deleted";
+
+interface ProjectInfo {
+    /** public project handle (projects.identifier) */
+    id: string;
+    name: string;
+    /** product discriminator, e.g. "web-project" (the editor) — opaque to the server */
+    kind?: string;
+    created_at?: string | null;
+    updated_at?: string | null;
+    /** set = the project is ARCHIVED (read-only; pushes return 409) */
+    archived_at?: string | null;
+    /** set = the project is in the BIN (only on ?state=deleted listings) */
+    deleted_at?: string | null;
+    /** user-editable metadata — opaque to the server */
+    description?: string | null;
+    tags?: string[] | null;
+    /** newest revision's actor id — null for a project with no pushes */
+    updated_by?: string | null;
+    /** resolved display name of updated_by (cached lookup) — null when unresolvable */
+    updated_by_name?: string | null;
+}
+
+interface ProjectRevisionInfo {
+    /** resolved display name of the actor (server-side cached Logto lookup);
+     * null when unresolvable — the actor ID stays the stored truth.
+     * Present on the revisions LISTING only. */
+    actorName?: string | null;
+    /** 1-based, strictly increasing per project */
+    revision: number;
+    /** the revision this push was built on (0 for the first) */
+    baseRevision: number;
+    /** sha-256 hex of the full document bytes */
+    hash: string;
+    /** token identity of the pusher — never client-supplied */
+    actor: string;
+    /** ISO timestamp */
+    timestamp: string | null;
+}
+
+interface CreateProjectResponse {
+    id: string;
+    name: string;
+    kind?: string;
+}
+
+interface ListProjectsResponse {
+    projects: ProjectInfo[];
+}
+
+/** PARTIAL update: absent = keep, null = clear */
+interface UpdateProjectRequest {
+    name?: string;
+    description?: string | null;
+    /** max 20 tags, 1-64 characters each (deduped server-side) */
+    tags?: string[] | null;
+}
+
+interface UpdateProjectResponse {
+    id: string;
+    name: string;
+    description: string | null;
+    tags: string[] | null;
+}
+
+interface CloneProjectResponse {
+    /** the COPY's public handle */
+    id: string;
+    name: string;
+    kind?: string;
+    /** the source project's handle */
+    sourceId: string;
+}
+
+interface ProjectHeadResponse {
+    head: ProjectRevisionInfo | null;
+}
+
+interface PushProjectRequest {
+    /** project id (public handle) */
+    project: string;
+    /** optimistic-concurrency token: the revision the client built on */
+    baseRevision: number;
+    /** sha-256 hex of the decoded bytes — verified server-side */
+    hash: string;
+    /** base64 document bytes */
+    bytes: string;
+}
+
+interface PushProjectResponse {
+    /** ok = revision minted; unchanged = identical to head, nothing minted;
+     *  stale = head moved past the base — pull, merge client-side, retry */
+    status: "ok" | "unchanged" | "stale";
+    head: ProjectRevisionInfo;
+}
+
+interface PullProjectResponse {
+    info: ProjectRevisionInfo;
+    /** base64 document bytes */
+    bytes: string;
+}
+
+/**
+ * @internal Needle editor cloud projects — versioned revisions of OPAQUE
+ * project documents. Editor-only, NO stability guarantee (needle-cloud
+ * plans/cloud-projects-api.md): the document format is young and this
+ * surface changes with it. The server never parses a document.
+ *
+ * Auth mirrors {@link listContent}: browser session unless an explicit
+ * `authToken` is passed (the Needle editor's identity service does).
+ */
+/**
+ * @internal
+ * @param {string} name
+ * @param {{ org?: string, authToken?: string, kind: string }} opts - kind = product discriminator, REQUIRED (editor: "web-project")
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").CreateProjectResponse>}
+ */
+declare function createProject(name: string, opts: {
+    org?: string;
+    authToken?: string;
+    kind: string;
+}): Promise<CreateProjectResponse>;
+/**
+ * @internal
+ * @param {{ org?: string, authToken?: string, kind?: string, state?: import("@needle-tools/cloud-sdk/types/api.projects").ProjectState }} [opts] - kind filters to one product's projects; state = "active" (default) | "archived" | "deleted" (the bin)
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").ListProjectsResponse>}
+ */
+declare function listProjects(opts?: {
+    org?: string;
+    authToken?: string;
+    kind?: string;
+    state?: ProjectState;
+}): Promise<ListProjectsResponse>;
+/**
+ * @internal
+ * @param {string} project - project id (public handle)
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").ProjectHeadResponse>}
+ */
+declare function getProjectHead(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<ProjectHeadResponse>;
+/**
+ * @internal
+ * @param {import("@needle-tools/cloud-sdk/types/api.projects").PushProjectRequest} request
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").PushProjectResponse>}
+ */
+declare function pushProjectRevision(request: PushProjectRequest, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<PushProjectResponse>;
+/**
+ * @internal Resolves to null when the project or revision does not exist —
+ * callers (the editor's project remote) treat that as "nothing to pull",
+ * not an error.
+ * @param {string} project - project id (public handle)
+ * @param {number} [revision] - specific revision; head when omitted
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").PullProjectResponse | null>}
+ */
+declare function pullProjectRevision(project: string, revision?: number, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<PullProjectResponse | null>;
+/**
+ * @internal SOFT delete — history and blobs are preserved server-side.
+ * @param {string} project - project id (public handle)
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{id: string, message: string}>}
+ */
+declare function deleteProject(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    id: string;
+    message: string;
+}>;
+/**
+ * @internal Un-delete a project from the bin (bounded server-side to the bin window).
+ * @param {string} project - project id (public handle)
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{id: string, message: string}>}
+ */
+declare function restoreProject(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    id: string;
+    message: string;
+}>;
+/**
+ * @internal Archive = read-only + hidden from the default list; pushes return 409.
+ * @param {string} project - project id (public handle)
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{id: string, message: string}>}
+ */
+declare function archiveProject(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    id: string;
+    message: string;
+}>;
+/**
+ * @internal
+ * @param {string} project - project id (public handle)
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{id: string, message: string}>}
+ */
+declare function unarchiveProject(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    id: string;
+    message: string;
+}>;
+/**
+ * @internal Duplicate a project inside its org — zero-copy server-side.
+ * @param {string} project - source project id (public handle)
+ * @param {{ org?: string, authToken?: string, name?: string }} [opts] - the copy's name; "<source> (copy)" when omitted
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").CloneProjectResponse>}
+ */
+declare function cloneProject(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+    name?: string;
+}): Promise<CloneProjectResponse>;
+/**
+ * @internal PARTIAL metadata update — absent fields stay, null clears.
+ * @param {string} project - project id (public handle)
+ * @param {import("@needle-tools/cloud-sdk/types/api.projects").UpdateProjectRequest} patch
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<import("@needle-tools/cloud-sdk/types/api.projects").UpdateProjectResponse>}
+ */
+declare function updateProject(project: string, patch: UpdateProjectRequest, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<UpdateProjectResponse>;
+/**
+ * @internal Which of these file-blob hashes the org pool does not hold yet.
+ * @param {readonly string[]} hashes
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{ missing: string[] }>}
+ */
+declare function checkProjectBlobs(hashes: readonly string[], opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    missing: string[];
+}>;
+/**
+ * @internal Presigned PUT url for one file blob.
+ * @param {string} hash
+ * @param {number} size
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{ url: string, key: string }>}
+ */
+declare function requestProjectBlobUpload(hash: string, size: number, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    url: string;
+    key: string;
+}>;
+/**
+ * @internal Complete (HEAD-verify + index) an uploaded file blob.
+ * @param {string} hash
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{ hash: string, size: number }>}
+ */
+declare function completeProjectBlobUpload(hash: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    hash: string;
+    size: number;
+}>;
+/**
+ * @internal Presigned GET url for a file blob; null when absent.
+ * @param {string} hash
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{ url: string, size: number } | null>}
+ */
+declare function requestProjectBlobDownload(hash: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    url: string;
+    size: number;
+} | null>;
+/**
+ * @internal Revision history of a project, newest first.
+ * @param {string} project
+ * @param {{ org?: string, authToken?: string }} [opts]
+ * @returns {Promise<{ revisions: import("@needle-tools/cloud-sdk/types/api.projects").ProjectRevisionInfo[] }>}
+ */
+declare function listProjectRevisions(project: string, opts?: {
+    org?: string;
+    authToken?: string;
+}): Promise<{
+    revisions: ProjectRevisionInfo[];
+}>;
+
 /**
  * Start the checkout process
  * @param {{ price_id:string }} args
@@ -1420,5 +1825,5 @@ declare namespace AuthScopes {
     let All: string[];
 }
 
-export { Auth, AuthScopes, NeedleLoginButton, createChatSession, getContent, getDeployments, getPublicContent, getUserLicenses, listChats, listContent, listPublicContent, ownsProduct, startCheckoutSession, uploadFiles };
+export { Auth, AuthScopes, NeedleLoginButton, archiveProject, checkProjectBlobs, cloneProject, completeProjectBlobUpload, createChatSession, createProject, deleteProject, getContent, getDeployments, getProjectHead, getPublicContent, getUserLicenses, listChats, listContent, listProjectRevisions, listProjects, listPublicContent, ownsProduct, pullProjectRevision, pushProjectRevision, requestProjectBlobDownload, requestProjectBlobUpload, restoreProject, startCheckoutSession, unarchiveProject, updateProject, uploadFiles };
 export type { AuthData, AuthInitOpts, ChatAuthOpts, ChatSessionHandle, ChatSessionOptions, ChatSessionSendOptions, Deployment, Filelike, LogtoUserCustomData, RecentChatsResponse, ResourceUrl, ToolDefinition, UserInfoResponse };