@crewx/sdk 0.9.0-rc.15 → 0.9.0-rc.151

package/README.md

@@ -128,7 +128,7 @@ const result = await crewx.query('assistant', 'Translate to Korean', {
 });
 ```
 
-> **Note**: `'@assistant'` 형태도 동작합니다 (CLI 호환). SDK에서는 bare id가 권장됩니다.
+> **Note**: The `'@assistant'` form also works (CLI-compatible). The SDK recommends using the bare id.
 
 **Returns**: [`QueryResult`](#queryresult)
 

package/dist/account/auth-client.d.ts

@@ -0,0 +1,61 @@
+export declare const DEVICE_CODE_PATH: "/auth/v1/oauth/device/code";
+export declare const TOKEN_PATH: "/auth/v1/oauth/token";
+export declare const REVOKE_PATH: "/auth/v1/oauth/revoke";
+export declare const OAUTH_CLIENT_ID: "crewx-cli";
+export declare const DEVICE_CODE_GRANT_TYPE: "urn:ietf:params:oauth:grant-type:device_code";
+export interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval?: number;
+}
+export type DeviceCodeResult = DeviceCodeResponse;
+export interface AccountIdentity {
+    sub: string;
+    email: string;
+}
+export interface OAuthTokenResponse {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    token_type?: string;
+    scope?: string;
+    account: AccountIdentity;
+}
+export type TokenResponse = OAuthTokenResponse;
+export type AuthTokenGrant = {
+    grant_type: typeof DEVICE_CODE_GRANT_TYPE;
+    device_code: string;
+} | {
+    grant_type: 'refresh_token';
+    refresh_token: string;
+};
+export interface AuthClientOptions {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare class AuthClient {
+    private readonly configuredBaseUrl?;
+    private readonly fetchImpl?;
+    private readonly timeoutMs;
+    constructor(options?: AuthClientOptions | string);
+    private baseUrl;
+    private signal;
+    private request;
+    requestDeviceCode(): Promise<DeviceCodeResponse>;
+    requestToken(grant: AuthTokenGrant): Promise<OAuthTokenResponse>;
+    exchangeDeviceCode(deviceCode: string): Promise<OAuthTokenResponse>;
+    refreshToken(refreshToken: string): Promise<OAuthTokenResponse>;
+    deviceCode(): Promise<DeviceCodeResponse>;
+    getDeviceCode(): Promise<DeviceCodeResponse>;
+    token(grant: AuthTokenGrant): Promise<OAuthTokenResponse>;
+    getToken(grant: AuthTokenGrant): Promise<OAuthTokenResponse>;
+    refresh(refreshToken: string): Promise<OAuthTokenResponse>;
+    refreshAccessToken(refreshToken: string): Promise<OAuthTokenResponse>;
+    revokeToken(refreshToken: string): Promise<void>;
+    revoke(refreshToken: string): Promise<void>;
+}

package/dist/account/auth-json-v2.d.ts

@@ -0,0 +1 @@
+export * from './auth-json';

package/dist/account/auth-json.d.ts

@@ -0,0 +1,30 @@
+export declare const AUTH_JSON_FILENAME: "auth.json";
+export declare const AUTH_JSON_VERSION: 2;
+export interface AuthJsonV2 {
+    version: 2;
+    sub: string;
+    email: string;
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    updated_at: string;
+}
+export type AuthJson = AuthJsonV2;
+export type AuthSession = AuthJsonV2;
+export declare function isAuthJsonV2(value: unknown): value is AuthJsonV2;
+export declare function validateAuthJson(value: unknown): AuthJsonV2;
+export declare function parseAuthJson(raw: string): AuthJsonV2;
+export declare function authJsonPath(filePath?: string): string;
+export declare class AuthJsonStore {
+    private readonly configuredPath?;
+    constructor(options?: {
+        filePath?: string;
+    } | string);
+    path(): string;
+    read(): AuthJsonV2 | null;
+    write(value: AuthJsonV2): void;
+    clear(): void;
+}
+export declare function readAuthJson(filePath?: string): AuthJsonV2;
+export declare function writeAuthJson(value: AuthJsonV2, filePath?: string): void;
+export declare function clearAuthJson(filePath?: string): void;

package/dist/account/config.d.ts

@@ -0,0 +1,37 @@
+export declare const ACCOUNT_BASE_URL_ENV: "CREWX_ACCOUNT_BASE_URL";
+export declare const ACCOUNT_ISSUER_ENV: "CREWX_ACCOUNT_ISSUER";
+export declare const MARKETPLACE_URL_ENV: "CREWX_MARKETPLACE_URL";
+export declare const ACCOUNT_TARGET_ENV: "CREWX_TARGET";
+export declare const MARKETPLACE_DISABLED_ENV: "CREWX_MARKETPLACE_DISABLED";
+export declare const PRODUCTION_TARGET: Readonly<{
+    readonly accountBaseUrl: "https://app.sowonai.com";
+    readonly marketplaceUrl: "https://market.sowonai.com";
+}>;
+export declare const LOCAL_TARGET: Readonly<{
+    readonly accountBaseUrl: "http://127.0.0.1:3030";
+    readonly marketplaceUrl: "http://127.0.0.1:4000";
+}>;
+export declare const DEFAULT_ACCEPTED_ISSUERS: readonly ["https://app.sowonai.com/auth/v1", "https://auth.sowonai.com/auth/v1"];
+export type Environment = Readonly<Record<string, string | undefined>>;
+export type AccountTargetProfile = 'production' | 'local' | 'custom';
+export type AccountTargetSource = 'env' | 'profile' | 'default' | 'disabled';
+export interface AccountTarget {
+    accountBaseUrl: string;
+    marketplaceUrl: string | null;
+    issuers: readonly string[];
+    profile: AccountTargetProfile;
+    sources: {
+        accountBaseUrl: Exclude<AccountTargetSource, 'disabled'>;
+        marketplaceUrl: AccountTargetSource;
+        issuer: Exclude<AccountTargetSource, 'disabled'>;
+    };
+    mixed: boolean;
+    marketplaceDisabled: boolean;
+}
+export declare function resolveAccountBaseUrl(env?: Environment): string;
+export declare function resolveMarketplaceUrl(env?: Environment): string;
+export declare function resolveAcceptedAccountIssuers(env?: Environment): readonly string[];
+export declare function resolveAccountIssuer(env?: Environment): string;
+export declare function resolveAccountTarget(env?: Environment): AccountTarget;
+export declare function assertAccountTargetNotMixed(env?: Environment): void;
+export declare function appendEndpoint(baseUrl: string, endpoint: string): string;

package/dist/account/env-bootstrap.d.ts

@@ -0,0 +1,11 @@
+export declare const CREWX_TASK_TICKET_SECRET_ENV: "CREWX_TASK_TICKET_SECRET";
+export interface CrewxEnvFileOptions {
+    workspaceDir?: string;
+    homeDir?: string;
+}
+export declare function resolveCrewxEnvFilePaths(options?: CrewxEnvFileOptions): {
+    workspace: string;
+    home: string;
+};
+export declare function readCrewxEnvFileKeys(path: string): ReadonlySet<string>;
+export declare function loadCrewxEnvFiles(options?: CrewxEnvFileOptions): void;

package/dist/account/errors.d.ts

@@ -0,0 +1,24 @@
+export type AccountAuthErrorKind = 'configuration' | 'network' | 'server' | 'invalid_refresh' | 'pending' | 'denied' | 'expired' | 'http' | 'protocol';
+export declare class AccountAuthError extends Error {
+    readonly code: string;
+    readonly kind: AccountAuthErrorKind;
+    readonly status?: number;
+    constructor(code: string, kind: AccountAuthErrorKind, status?: number, message?: string);
+}
+export { AccountAuthError as AuthClientError, AccountAuthError as AuthError };
+export declare class LoginRequiredError extends Error {
+    readonly code: "LOGIN_REQUIRED";
+    constructor();
+}
+export declare class SessionManagerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export type AuthJsonValidationCode = 'AUTH_JSON_LEGACY' | 'AUTH_JSON_INVALID';
+export declare class AuthJsonValidationError extends Error {
+    readonly code: AuthJsonValidationCode;
+    constructor(code: AuthJsonValidationCode, message?: string);
+}
+export declare class AccountConfigurationError extends AccountAuthError {
+    constructor(code: 'ACCOUNT_BASE_URL_MISSING' | 'ACCOUNT_BASE_URL_INVALID' | 'ACCOUNT_ISSUER_MISSING' | 'ACCOUNT_ISSUER_INVALID' | 'MARKETPLACE_URL_MISSING' | 'MARKETPLACE_URL_INVALID' | 'ACCOUNT_TARGET_INVALID' | 'ACCOUNT_TARGET_MIXED' | 'MARKETPLACE_DISABLED');
+}

package/dist/account/index.d.ts

@@ -0,0 +1,12 @@
+export { ACCOUNT_BASE_URL_ENV, ACCOUNT_ISSUER_ENV, ACCOUNT_TARGET_ENV, DEFAULT_ACCEPTED_ISSUERS, LOCAL_TARGET, MARKETPLACE_DISABLED_ENV, MARKETPLACE_URL_ENV, PRODUCTION_TARGET, appendEndpoint, assertAccountTargetNotMixed, resolveAccountBaseUrl, resolveAccountTarget, resolveAcceptedAccountIssuers, resolveAccountIssuer, resolveMarketplaceUrl, } from './config';
+export type { AccountTarget, AccountTargetProfile, AccountTargetSource, Environment, } from './config';
+export { CREWX_TASK_TICKET_SECRET_ENV, loadCrewxEnvFiles, readCrewxEnvFileKeys, resolveCrewxEnvFilePaths, } from './env-bootstrap';
+export type { CrewxEnvFileOptions } from './env-bootstrap';
+export { AccountAuthError, AuthClientError, AuthError, AccountConfigurationError, AuthJsonValidationError, LoginRequiredError, SessionManagerError, } from './errors';
+export type { AccountAuthErrorKind, AuthJsonValidationCode } from './errors';
+export { AUTH_JSON_FILENAME, AUTH_JSON_VERSION, AuthJsonStore, authJsonPath, clearAuthJson, isAuthJsonV2, parseAuthJson, readAuthJson, validateAuthJson, writeAuthJson, } from './auth-json';
+export type { AuthJson, AuthJsonV2, AuthSession } from './auth-json';
+export { AuthClient, DEVICE_CODE_GRANT_TYPE, DEVICE_CODE_PATH, OAUTH_CLIENT_ID, REVOKE_PATH, TOKEN_PATH, } from './auth-client';
+export type { AccountIdentity, AuthClientOptions, AuthTokenGrant, DeviceCodeResponse, DeviceCodeResult, OAuthTokenResponse, TokenResponse, } from './auth-client';
+export { SessionManager } from './session-manager';
+export type { AccountAuthClient, AuthJsonStorage, AuthSessionStore, SessionManagerOptions } from './session-manager';

package/dist/account/index.js

@@ -0,0 +1,2 @@
+'use strict';var dotenv=require('dotenv'),z=require('fs'),T=require('path'),$=require('os'),crypto=require('crypto');function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}var z__namespace=/*#__PURE__*/_interopNamespace(z);var T__namespace=/*#__PURE__*/_interopNamespace(T);var $__namespace=/*#__PURE__*/_interopNamespace($);var s=class extends Error{code;kind;status;constructor(e,n,r,o){super(o??`Account authentication request failed (${e})`),this.name="AccountAuthError",this.code=e,this.kind=n,this.status=r;}};var l=class extends Error{code="LOGIN_REQUIRED";constructor(){super("Login required \u2014 please log in again"),this.name="LoginRequiredError";}},f=class extends Error{code;constructor(e,n){super(n),this.name="SessionManagerError",this.code=e;}},p=class extends Error{code;constructor(e,n="auth.json is invalid \u2014 please log in again"){super(n),this.name="AuthJsonValidationError",this.code=e;}},i=class extends s{constructor(e){let n=e.startsWith("ACCOUNT_BASE_URL")?"CREWX_ACCOUNT_BASE_URL":e.startsWith("ACCOUNT_ISSUER")?"CREWX_ACCOUNT_ISSUER":e==="ACCOUNT_TARGET_INVALID"?"CREWX_TARGET":e==="ACCOUNT_TARGET_MIXED"?"CREWX_ACCOUNT_BASE_URL/CREWX_MARKETPLACE_URL":e==="MARKETPLACE_DISABLED"?"CREWX_MARKETPLACE_DISABLED":"CREWX_MARKETPLACE_URL",r=e==="ACCOUNT_TARGET_MIXED"?`${n} must not mix loopback and public hosts \u2014 choose one account target`:e==="MARKETPLACE_DISABLED"?`${n} disables Marketplace access`:`${n} is missing or invalid \u2014 configure it and try again`;super(e,"configuration",void 0,r),this.name="AccountConfigurationError";}};var N="CREWX_ACCOUNT_BASE_URL",k="CREWX_ACCOUNT_ISSUER",O="CREWX_MARKETPLACE_URL",x="CREWX_TARGET",j="CREWX_MARKETPLACE_DISABLED",y=Object.freeze({accountBaseUrl:"https://app.sowonai.com",marketplaceUrl:"https://market.sowonai.com"}),R=Object.freeze({accountBaseUrl:"http://127.0.0.1:3030",marketplaceUrl:"http://127.0.0.1:4000"}),L=Object.freeze(["https://app.sowonai.com/auth/v1","https://auth.sowonai.com/auth/v1"]);function D(t,e,n=false){let r=t?.trim();if(!r)throw new i(e);try{let o=new URL(r);if(o.protocol!=="http:"&&o.protocol!=="https:"||o.username.length>0||o.password.length>0||o.hostname.length===0||o.search.length>0||o.hash.length>0||n&&o.pathname!=="/")throw new Error("invalid URL")}catch{throw new i(e)}return r.replace(/\/+$/,"")}function X(t){let e=t?.trim();if(!e)throw new i("ACCOUNT_ISSUER_INVALID");try{let n=new URL(e);if(n.protocol!=="http:"&&n.protocol!=="https:"||n.username.length>0||n.password.length>0||n.hostname.length===0||n.search.length>0||n.hash.length>0)throw new Error("invalid issuer")}catch{throw new i("ACCOUNT_ISSUER_INVALID")}return e}function P(t){let e=t[x];if(e===void 0)return "production";let n=e.trim();if(n==="local"||n==="production")return n;throw new i("ACCOUNT_TARGET_INVALID")}function q(t){let e=t[j]?.trim().toLowerCase();return e==="1"||e==="true"}function b(t){return t==="local"?R:y}function V(t=process.env){let e=P(t),n=t[N];return n!==void 0?D(n,"ACCOUNT_BASE_URL_INVALID",true):b(e).accountBaseUrl}function fe(t=process.env){let e=P(t);if(q(t))throw new i("MARKETPLACE_DISABLED");let n=t[O];return n!==void 0?D(n,"MARKETPLACE_URL_INVALID"):b(e).marketplaceUrl}function I(t=process.env){let e=t[k];return e===void 0?L:[X(e)]}function de(t=process.env){return I(t)[0]}function G(t,e,n,r=false){if(t===void 0)return e;try{return D(t,n,r)}catch{return t.trim()}}function Ae(t){let e=t[k];if(e===void 0)return L;try{return [X(e)]}catch{return [e.trim()]}}function W(t){if(t===null)return  false;try{let e=new URL(t).hostname.toLowerCase();return e==="127.0.0.1"||e==="localhost"||e==="[::1]"||e==="::1"}catch{return  false}}function _e(t,e){return e!==null&&t===y.accountBaseUrl&&e===y.marketplaceUrl?"production":e!==null&&t===R.accountBaseUrl&&e===R.marketplaceUrl?"local":"custom"}function F(t=process.env){let e,n=true;try{e=P(t);}catch{e="production",n=false;}let r=b(e),o=t[x]!==void 0&&n,c=t[N],m=t[O],u=q(t),d=G(c,r.accountBaseUrl,"ACCOUNT_BASE_URL_INVALID",true),S=u?null:G(m,r.marketplaceUrl,"MARKETPLACE_URL_INVALID");return {accountBaseUrl:d,marketplaceUrl:S,issuers:Ae(t),profile:_e(d,S),sources:{accountBaseUrl:c===void 0?o?"profile":"default":"env",marketplaceUrl:u?"disabled":m===void 0?o?"profile":"default":"env",issuer:t[k]===void 0?"default":"env"},mixed:S!==null&&W(d)!==W(S),marketplaceDisabled:u}}function ge(t=process.env){if(F(t).mixed)throw new i("ACCOUNT_TARGET_MIXED")}function J(t,e){return `${t.replace(/\/+$/,"")}/${e.replace(/^\/+/,"")}`}function U(){if(process.env.CREWX_HOME){let t=T__namespace.resolve(process.env.CREWX_HOME);try{return z__namespace.realpathSync(t)}catch(e){if(e instanceof Error&&"code"in e&&e.code==="ENOENT")return t;throw e}}return process.platform!=="win32"&&process.env.XDG_CONFIG_HOME?T__namespace.join(process.env.XDG_CONFIG_HOME,"crewx"):T__namespace.join($__namespace.homedir(),".crewx")}var ee="CREWX_TASK_TICKET_SECRET";function te(t={}){let e=t.workspaceDir??process.env.CREWX_WORKSPACE??process.cwd(),n=t.homeDir??U();return {workspace:T.join(e,".env"),home:T.join(n,".env")}}function Ee(t){try{return new Set(Object.keys(dotenv.parse(z.readFileSync(t))))}catch(e){if(e?.code==="ENOENT")return new Set;throw e}}function me(t){try{return dotenv.parse(z.readFileSync(t))}catch(e){if(e?.code==="ENOENT")return {};throw e}}function Te(t={}){let e=te(t);for(let n of [e.workspace,e.home]){let r=me(n);for(let[o,c]of Object.entries(r))o===ee||process.env[o]!==void 0||(process.env[o]=c);}}var se="auth.json",B=2,oe=["version","sub","email","access_token","refresh_token","expires_at","updated_at"];function h(t="auth.json is invalid \u2014 please log in again"){throw new p("AUTH_JSON_INVALID",t)}function Ue(){throw new p("AUTH_JSON_LEGACY","auth.json uses an unsupported legacy format \u2014 please log in again")}function ve(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}function Ne(t){try{return g(t),!0}catch{return  false}}function g(t){if(!ve(t))return h();if(t.version===1)return Ue();if(t.version!==B)return h();let e=Object.keys(t);if(e.length!==oe.length||e.some(r=>!oe.includes(r))||typeof t.sub!="string"||t.sub.length===0||typeof t.email!="string"||t.email.length===0||typeof t.access_token!="string"||t.access_token.length===0||typeof t.refresh_token!="string"||t.refresh_token.length===0)return h();let n=t.expires_at;return typeof n!="number"||!Number.isSafeInteger(n)||n<0||typeof t.updated_at!="string"||t.updated_at.length===0||Number.isNaN(Date.parse(t.updated_at))?h():{version:B,sub:t.sub,email:t.email,access_token:t.access_token,refresh_token:t.refresh_token,expires_at:n,updated_at:t.updated_at}}function ie(t){let e;try{e=JSON.parse(t);}catch{return h()}return g(e)}function ce(t){return t??T.join(U(),se)}var A=class{configuredPath;constructor(e={}){this.configuredPath=typeof e=="string"?e:e.filePath;}path(){return ce(this.configuredPath)}read(){let e=this.path();if(!z.existsSync(e))return null;try{return ie(z.readFileSync(e,"utf8"))}catch(n){throw n instanceof p?n:new p("AUTH_JSON_INVALID")}}write(e){let n=g(e),r=this.path(),o=T.dirname(r);z.mkdirSync(o,{recursive:true,mode:448});let c=`${r}.tmp.${process.pid}.${crypto.randomUUID()}`;try{z.writeFileSync(c,JSON.stringify(n,null,2),{encoding:"utf8",mode:384}),z.chmodSync(c,384),z.renameSync(c,r),z.chmodSync(r,384);}catch{try{z.existsSync(c)&&z.unlinkSync(c);}catch{}throw new Error("Could not persist auth.json securely")}}clear(){let e=this.path();try{z.existsSync(e)&&z.unlinkSync(e);}catch{throw new Error("Could not clear auth.json")}}};function Oe(t){let e=new A({filePath:t}).read();if(!e)throw new l;return e}function xe(t,e){new A({filePath:e}).write(t);}function Le(t){new A({filePath:t}).clear();}var ue="/auth/v1/oauth/device/code",pe="/auth/v1/oauth/token",he="/auth/v1/oauth/revoke",v="crewx-cli",E="urn:ietf:params:oauth:grant-type:device_code";function a(t){return typeof t=="string"&&t.trim().length>0}function C(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)?t:null}function De(t){let e=C(t),n=e?.error??e?.code;if(typeof n=="string")return n.toLowerCase();let r=C(n),o=r?.code??r?.error;return typeof o=="string"?o.toLowerCase():void 0}function Pe(t){let e=C(t);if(!e||!a(e.device_code)||!a(e.user_code)||!a(e.verification_uri))throw new s("AUTH_RESPONSE_INVALID","protocol");let n=e.expires_in,r=e.interval;if(typeof n!="number"||!Number.isSafeInteger(n)||n<=0)throw new s("AUTH_RESPONSE_INVALID","protocol");if(e.verification_uri_complete!==void 0&&!a(e.verification_uri_complete))throw new s("AUTH_RESPONSE_INVALID","protocol");if(r!==void 0&&(typeof r!="number"||!Number.isSafeInteger(r)||r<0))throw new s("AUTH_RESPONSE_INVALID","protocol");let o={device_code:e.device_code,user_code:e.user_code,verification_uri:e.verification_uri,expires_in:n};return e.verification_uri_complete!==void 0&&(o.verification_uri_complete=e.verification_uri_complete),r!==void 0&&(o.interval=r),o}function be(t){let e=C(t),n=C(e?.account),r=e?.expires_in;if(!e||!a(e.access_token)||!a(e.refresh_token)||typeof r!="number"||!Number.isSafeInteger(r)||r<=0||!n||!a(n.sub)||!a(n.email))throw new s("AUTH_RESPONSE_INVALID","protocol");let o={access_token:e.access_token,refresh_token:e.refresh_token,expires_in:r,account:{sub:n.sub,email:n.email}};return typeof e.token_type=="string"&&e.token_type.length>0&&(o.token_type=e.token_type),typeof e.scope=="string"&&e.scope.length>0&&(o.scope=e.scope),o}var w=class{configuredBaseUrl;fetchImpl;timeoutMs;constructor(e={}){let n=typeof e=="string"?{baseUrl:e}:e;this.configuredBaseUrl=n.baseUrl===void 0?void 0:Ve(n.baseUrl),this.fetchImpl=n.fetch??n.fetchImpl,this.timeoutMs=n.timeoutMs??1e4;}baseUrl(){return this.configuredBaseUrl!==void 0?this.configuredBaseUrl:V()}signal(e){if(!(e<=0||typeof AbortSignal>"u"||typeof AbortSignal.timeout!="function"))return AbortSignal.timeout(e)}async request(e,n,r,o={}){let c=J(this.baseUrl(),e),m=this.fetchImpl??globalThis.fetch;if(typeof m!="function")throw new s("AUTH_NETWORK_ERROR","network");let u;try{u=await m(c,{...n,signal:n.signal??this.signal(o.timeoutMs??this.timeoutMs)});}catch{throw new s("AUTH_NETWORK_ERROR","network")}if(o.parseBody===false){if(!u.ok)throw ae(u.status,null,r);return}let d=null;try{d=await u.json();}catch{d=null;}if(!u.ok)throw ae(u.status,d,r);return d}async requestDeviceCode(){let e=new URLSearchParams;e.set("client_id",v);let n=await this.request(ue,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:e.toString()});return Pe(n)}async requestToken(e){Je(e);let n=new URLSearchParams;n.set("grant_type",e.grant_type),n.set("client_id",v),e.grant_type===E?n.set("device_code",e.device_code):n.set("refresh_token",e.refresh_token);let r=await this.request(pe,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:n.toString()},e);return be(r)}async exchangeDeviceCode(e){return this.requestToken({grant_type:E,device_code:e})}async refreshToken(e){return this.requestToken({grant_type:"refresh_token",refresh_token:e})}async deviceCode(){return this.requestDeviceCode()}async getDeviceCode(){return this.requestDeviceCode()}async token(e){return this.requestToken(e)}async getToken(e){return this.requestToken(e)}async refresh(e){return this.refreshToken(e)}async refreshAccessToken(e){return this.refreshToken(e)}async revokeToken(e){if(!a(e))throw new s("AUTH_INPUT_INVALID","protocol");let n=new URLSearchParams;n.set("token",e),n.set("token_type_hint","refresh_token"),n.set("client_id",v),await this.request(he,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:n.toString()},void 0,{parseBody:false,timeoutMs:3e3});}async revoke(e){return this.revokeToken(e)}};function Ve(t){if(typeof t!="string"||!t.trim())throw new i("ACCOUNT_BASE_URL_INVALID");try{let e=new URL(t.trim());if(e.protocol!=="http:"&&e.protocol!=="https:"||e.username.length>0||e.password.length>0||e.hostname.length===0||e.pathname!=="/"||e.search.length>0||e.hash.length>0)throw new Error("invalid URL")}catch{throw new i("ACCOUNT_BASE_URL_INVALID")}return t.trim().replace(/\/+$/,"")}function Je(t){if(!t||t.grant_type!==E&&t.grant_type!=="refresh_token"||t.grant_type===E&&!a(t.device_code)||t.grant_type==="refresh_token"&&!a(t.refresh_token))throw new s("AUTH_INPUT_INVALID","protocol")}function ae(t,e,n){let r=De(e);if(t>=500)return new s("AUTH_SERVER_ERROR","server",t);if(n?.grant_type==="refresh_token"&&(r==="invalid_grant"||t===401))return new s("INVALID_REFRESH_TOKEN","invalid_refresh",t);if(n?.grant_type===E){if(r==="authorization_pending")return new s("AUTHORIZATION_PENDING","pending",t);if(r==="slow_down")return new s("SLOW_DOWN","pending",t);if(r==="access_denied")return new s("ACCESS_DENIED","denied",t);if(r==="expired_token")return new s("EXPIRED_TOKEN","expired",t)}return new s("AUTH_HTTP_ERROR","http",t)}var K=class{client;store;refreshSkewSeconds;now;nowSecondsOverride;refreshPromise=null;constructor(e={},n){let r=Be(e)?e:void 0,o=r?{}:e;this.client=r??o.client??o.authClient??new w,this.store=o.store??o.storage??n??new A,this.refreshSkewSeconds=o.refreshSkewSeconds??60,this.now=o.now??(()=>Date.now()),this.nowSecondsOverride=o.nowSeconds;}getSession(){return this.readSession()}isLoggedIn(){return this.readSession()!==null}async getAccessToken(){let e=this.requireSession();return e.expires_at>this.epochSeconds()+this.refreshSkewSeconds?e.access_token:(await this.refreshSession(e)).access_token}async getValidAccessToken(){return this.getAccessToken()}async getToken(){return this.getAccessToken()}async refresh(){return this.refreshSession(this.requireSession())}async loginWithDeviceCode(e){let n=await this.client.exchangeDeviceCode(e);return this.persistTokenResponse(n)}async login(e){return this.loginWithDeviceCode(e)}async setSession(e){return this.persistTokenResponse(e)}clear(){this.store.clear();}async withAccessToken(e){return e(await this.getAccessToken())}readSession(){try{let e=this.store.read();if(e===null)return null;let n=g(e);return le(n.access_token,n.sub),n}catch(e){throw e instanceof p?new l:e}}requireSession(){let e=this.readSession();if(!e)throw new l;return e}epochSeconds(){return this.nowSecondsOverride?.()??Math.floor(this.now()/1e3)}refreshSession(e){if(this.refreshPromise)return this.refreshPromise;let n;return n=this.performRefresh(e).finally(()=>{this.refreshPromise===n&&(this.refreshPromise=null);}),this.refreshPromise=n,n}async performRefresh(e){try{let n=await this.client.refreshToken(e.refresh_token);return this.persistTokenResponse(n,e.sub)}catch(n){throw Me(n)?(this.store.clear(),new l):n}}persistTokenResponse(e,n){let r=e?.account;if(!e||typeof e.access_token!="string"||e.access_token.length===0||typeof e.refresh_token!="string"||e.refresh_token.length===0||!Number.isSafeInteger(e.expires_in)||e.expires_in<=0||!r||typeof r.sub!="string"||r.sub.length===0||typeof r.email!="string"||r.email.length===0)throw new f("AUTH_RESPONSE_INVALID","Account token response is malformed");if(n!==void 0&&r.sub!==n)throw new f("ACCOUNT_SUB_MISMATCH","Account subject changed during token refresh \u2014 please log in again");le(e.access_token,r.sub);let o=g({version:2,sub:r.sub,email:r.email,access_token:e.access_token,refresh_token:e.refresh_token,expires_at:this.epochSeconds()+e.expires_in,updated_at:new Date(this.now()).toISOString()});return this.store.write(o),o}};function Me(t){return t instanceof s?t.kind==="invalid_refresh":typeof t=="object"&&t!==null&&(t.kind==="invalid_refresh"||t.code==="INVALID_REFRESH_TOKEN")}function Be(t){return typeof t.exchangeDeviceCode=="function"&&typeof t.refreshToken=="function"}function le(t,e){let n=I(),r=He(t);if(!n.includes(r.iss))throw new f("ACCOUNT_ISSUER_MISMATCH","Access token issuer does not match the configured account issuer \u2014 please log in again");if(r.sub!==e)throw new f("ACCOUNT_SUB_MISMATCH","Access token subject does not match the account session \u2014 please log in again")}function He(t){if(typeof t!="string")throw H();let e=t.split(".");if(e.length!==3||e.some(n=>!/^[A-Za-z0-9_-]+$/.test(n)))throw H();try{let n=JSON.parse(Buffer.from(e[1],"base64url").toString("utf8"));if(typeof n!="object"||n===null||Array.isArray(n)||typeof n.iss!="string"||n.iss.length===0||typeof n.sub!="string"||n.sub.length===0)throw new Error("missing identity claims");return {iss:n.iss,sub:n.sub}}catch{throw H()}}function H(){return new f("ACCESS_TOKEN_INVALID","Access token identity could not be verified \u2014 please log in again")}
+exports.ACCOUNT_BASE_URL_ENV=N;exports.ACCOUNT_ISSUER_ENV=k;exports.ACCOUNT_TARGET_ENV=x;exports.AUTH_JSON_FILENAME=se;exports.AUTH_JSON_VERSION=B;exports.AccountAuthError=s;exports.AccountConfigurationError=i;exports.AuthClient=w;exports.AuthClientError=s;exports.AuthError=s;exports.AuthJsonStore=A;exports.AuthJsonValidationError=p;exports.CREWX_TASK_TICKET_SECRET_ENV=ee;exports.DEFAULT_ACCEPTED_ISSUERS=L;exports.DEVICE_CODE_GRANT_TYPE=E;exports.DEVICE_CODE_PATH=ue;exports.LOCAL_TARGET=R;exports.LoginRequiredError=l;exports.MARKETPLACE_DISABLED_ENV=j;exports.MARKETPLACE_URL_ENV=O;exports.OAUTH_CLIENT_ID=v;exports.PRODUCTION_TARGET=y;exports.REVOKE_PATH=he;exports.SessionManager=K;exports.SessionManagerError=f;exports.TOKEN_PATH=pe;exports.appendEndpoint=J;exports.assertAccountTargetNotMixed=ge;exports.authJsonPath=ce;exports.clearAuthJson=Le;exports.isAuthJsonV2=Ne;exports.loadCrewxEnvFiles=Te;exports.parseAuthJson=ie;exports.readAuthJson=Oe;exports.readCrewxEnvFileKeys=Ee;exports.resolveAcceptedAccountIssuers=I;exports.resolveAccountBaseUrl=V;exports.resolveAccountIssuer=de;exports.resolveAccountTarget=F;exports.resolveCrewxEnvFilePaths=te;exports.resolveMarketplaceUrl=fe;exports.validateAuthJson=g;exports.writeAuthJson=xe;

package/dist/account/session-manager.d.ts

@@ -0,0 +1,47 @@
+import { type OAuthTokenResponse } from './auth-client';
+import { type AuthJsonV2 } from './auth-json';
+export interface AuthSessionStore {
+    read(): AuthJsonV2 | null;
+    write(value: AuthJsonV2): void;
+    clear(): void;
+}
+export interface AccountAuthClient {
+    exchangeDeviceCode(deviceCode: string): Promise<OAuthTokenResponse>;
+    refreshToken(refreshToken: string): Promise<OAuthTokenResponse>;
+}
+export interface SessionManagerOptions {
+    client?: AccountAuthClient;
+    authClient?: AccountAuthClient;
+    store?: AuthSessionStore;
+    storage?: AuthSessionStore;
+    refreshSkewSeconds?: number;
+    now?: () => number;
+    nowSeconds?: () => number;
+}
+export type AuthJsonStorage = AuthSessionStore;
+export declare class SessionManager {
+    private readonly client;
+    private readonly store;
+    private readonly refreshSkewSeconds;
+    private readonly now;
+    private readonly nowSecondsOverride?;
+    private refreshPromise;
+    constructor(options?: SessionManagerOptions | AccountAuthClient, store?: AuthSessionStore);
+    getSession(): AuthJsonV2 | null;
+    isLoggedIn(): boolean;
+    getAccessToken(): Promise<string>;
+    getValidAccessToken(): Promise<string>;
+    getToken(): Promise<string>;
+    refresh(): Promise<AuthJsonV2>;
+    loginWithDeviceCode(deviceCode: string): Promise<AuthJsonV2>;
+    login(deviceCode: string): Promise<AuthJsonV2>;
+    setSession(token: OAuthTokenResponse): Promise<AuthJsonV2>;
+    clear(): void;
+    withAccessToken<T>(callback: (accessToken: string) => Promise<T>): Promise<T>;
+    private readSession;
+    private requireSession;
+    private epochSeconds;
+    private refreshSession;
+    private performRefresh;
+    private persistTokenResponse;
+}

package/dist/activity-log/builder.d.ts

@@ -1,3 +1,11 @@
+export declare const PROMPT_PREPARATION_SLOW_THRESHOLD_MS = 3000;
+export interface ActivityLogRenderedEntry {
+    entry: ActivityEntry;
+    newestIndex: number;
+    bodyLimitChars: number;
+    bodyCharsShown: number | null;
+    originalBodyChars: number | null;
+}
 export declare function checkStale(tool: string, input: string | null, taskCompletedAt?: string | null): 'ok' | 'stale' | 'unknown';
 export interface ActivityEntry {
     tool: string;
@@ -6,18 +14,63 @@ export interface ActivityEntry {
     status: 'ok' | 'stale' | 'unknown';
     reusable: boolean;
 }
-export interface ActivityLogResult {
+export type CountTokens = (text: string) => number;
+export type ActivityLogOmissionReason = 'token_cap' | 'repository_limit';
+export interface ActivityLogOmission {
+    reason: ActivityLogOmissionReason;
+    count: number;
+    message: string;
+}
+export interface ActivityLogTaskResult {
+    taskId: string;
+    taskDistance: number;
+    tokenCap: number;
+    tokenCount: number;
+    includedEntries: number;
+    omittedEntries: number;
+    totalEntries: number;
+    omissions: ActivityLogOmission[];
+    entries: ActivityLogRenderedEntry[];
+    activityLog: string;
+    readable?: false;
+}
+export interface ActivityLogByTaskResult {
     threadId: string;
     agentId: string;
     lookback: number;
-    entries: ActivityEntry[];
-    totalEntries: number;
-    truncated: boolean;
+    activityLogTokenBudget: number;
+    baseEntryChars: number;
+    tasks: ActivityLogTaskResult[];
+    activityLogByTask: Map<string, string>;
+}
+export interface BuildActivityLogByTaskBudgetOptions {
+    threadId: string;
+    agentId: string;
+    lookback: number;
+    maxEntryChars?: number;
+    activityLogTokenBudget: number;
+    countTokens: CountTokens;
+    repositoryEntryLimit?: number;
+    currentTaskId?: string;
 }
-export declare function buildActivityLogByTask(opts: {
+export interface BuildActivityLogByTaskOptions {
     threadId: string;
     agentId: string;
     lookback: number;
     maxEntryChars?: number;
     decayRate?: number;
-}): Map<string, string>;
+    activityLogTokenBudget?: number;
+    countTokens?: CountTokens;
+    repositoryEntryLimit?: number;
+    currentTaskId?: string;
+}
+export interface ActivityLogResult {
+    threadId: string;
+    agentId: string;
+    lookback: number;
+    entries: ActivityEntry[];
+    totalEntries: number;
+    truncated: boolean;
+}
+export declare function buildActivityLogByTaskResult(opts: BuildActivityLogByTaskBudgetOptions): ActivityLogByTaskResult;
+export declare function buildActivityLogByTask(opts: BuildActivityLogByTaskOptions): Map<string, string>;

package/dist/agent/agent-list-view.d.ts

@@ -0,0 +1,19 @@
+import type { AgentConfig } from '../types';
+export interface AgentListFilters {
+    role?: string;
+    team?: string;
+    provider?: string;
+}
+export interface AgentListSnapshot {
+    agents: AgentConfig[];
+    total: number;
+    configPath: string | null;
+}
+export interface AgentListFormatOptions {
+    agents: readonly AgentConfig[];
+    total: number;
+    isFiltered: boolean;
+    configPath?: string | null;
+}
+export declare function filterAgentConfigs(agents: readonly AgentConfig[], filters: AgentListFilters): AgentConfig[];
+export declare function formatAgentList(options: AgentListFormatOptions): string;

package/dist/app/app.d.ts

@@ -0,0 +1,148 @@
+import type { UiContentMediaType } from './content-media-types.js';
+export type JsonObject = Record<string, unknown>;
+export type JsonSchema = Readonly<{
+    type: 'object';
+    properties: Readonly<Record<string, unknown>>;
+    required: readonly string[];
+    additionalProperties: false;
+}>;
+export type ToolResult = void | JsonObject | Promise<void | JsonObject>;
+export interface AppDefinition {
+    readonly manifestVersion: 2;
+    readonly pluginId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly name: string;
+    readonly description: string;
+    readonly icon?: string;
+    readonly tone?: string;
+    readonly entry: string;
+    readonly initialState: Readonly<{
+        path: string;
+    }>;
+    readonly dataPaths?: readonly string[];
+    readonly surfaces: readonly string[];
+    readonly size?: Readonly<Record<string, number>>;
+    readonly stateProjection: Readonly<{
+        allow: readonly string[];
+    }>;
+}
+export interface ToolContentInput {
+    readonly mediaType: UiContentMediaType;
+    readonly required?: boolean;
+}
+export interface ToolContentOutput {
+    readonly mediaType: UiContentMediaType;
+    readonly range?: boolean;
+}
+export interface ToolContentDeclaration {
+    readonly in?: ToolContentInput;
+    readonly out?: ToolContentOutput;
+}
+export interface ContentRangeRequest {
+    readonly startLine: number;
+    readonly lineCount: number;
+}
+export interface ContentRange extends ContentRangeRequest {
+    readonly totalLines: number;
+}
+export interface ToolContent {
+    readonly in?: {
+        readonly text: string;
+    };
+    readonly out?: {
+        readonly range?: ContentRangeRequest;
+    };
+}
+export interface ToolOptions {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchema;
+    readonly capability?: string;
+    readonly confirmation?: string;
+    readonly mutation?: boolean;
+    readonly dataInputs?: readonly string[];
+    readonly resultProjection?: Readonly<{
+        allow: readonly string[];
+    }>;
+    readonly content?: ToolContentDeclaration;
+}
+export interface AppContext {
+    readonly instanceId: string;
+    readonly threadId: string | null;
+    readonly actor: 'user' | 'agent';
+    readonly requestId: string;
+    readonly nowMs: number;
+}
+export interface AppRuntimeOptions<State extends JsonObject = JsonObject> {
+    readonly state?: State;
+    readonly workspaceRoot: string;
+    readonly context?: AppContext;
+}
+export type AppFailureOutcome = 'failed' | 'rejected';
+export interface AppErrorMapping {
+    readonly code: string;
+    readonly detail: string | null;
+    readonly outcome?: AppFailureOutcome;
+}
+export interface AppErrorOptions {
+    readonly outcome?: AppFailureOutcome;
+}
+export interface AppErrorContext {
+    readonly input: unknown;
+    readonly state: unknown;
+}
+export type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+export declare class AppError extends Error {
+    readonly code: string;
+    readonly detail: string | null;
+    readonly outcome: AppFailureOutcome;
+    constructor(code: string, detail?: string | null, options?: AppErrorOptions);
+}
+export declare function normalizeFailureOutcome(value: unknown): AppFailureOutcome;
+export declare class CrewXApp<State extends JsonObject = JsonObject> {
+    static readonly devtools: {
+        readonly log: boolean;
+    } | undefined;
+    private currentState;
+    private stateWasSet;
+    private answerBody;
+    private answerRange;
+    private readonly callContext;
+    readonly workspaceRoot: string;
+    constructor(options?: AppRuntimeOptions<State>);
+    get context(): AppContext;
+    get state(): DeepReadonly<State>;
+    get didSetState(): boolean;
+    setState(next: State): void;
+    get didSetContent(): boolean;
+    get producedContent(): {
+        readonly body: Uint8Array;
+        readonly range?: ContentRange;
+    } | undefined;
+    setContent(body: string | Uint8Array, range?: ContentRange): void;
+    emptyState(): State;
+    validate(_actionId: string, _input: JsonObject, _state: JsonObject): void | Promise<void>;
+    mapError(_error: unknown): AppErrorMapping;
+    errorState(code: string, detail: string | null, context: AppErrorContext): State;
+}
+export interface ToolDeclaration {
+    readonly methodName: string;
+    readonly options: ToolOptions;
+}
+export type CrewXAppConstructor = (new (options: AppRuntimeOptions) => CrewXApp) & {
+    readonly devtools?: {
+        readonly log?: boolean;
+    };
+    readonly definition: AppDefinition;
+    readonly [key: string]: unknown;
+};
+type DecoratedMethod<This, Input extends object, Result extends ToolResult> = (this: This, input: Input, content: ToolContent) => Result;
+export declare function Tool(options: ToolOptions): <This, Input extends object, Result extends ToolResult>(_method: DecoratedMethod<This, Input, Result>, context: ClassMethodDecoratorContext<This, DecoratedMethod<This, Input, Result>>) => void;
+export declare function getToolDeclarations(appClass: CrewXAppConstructor): ToolDeclaration[];
+export declare function generateToolDeclarations(appClass: CrewXAppConstructor): JsonObject[];
+export declare function generateManifest(appClass: CrewXAppConstructor, backendCommand: readonly string[]): JsonObject;
+export declare function isPlainRecord(value: unknown): value is JsonObject;
+export {};

package/dist/app/backend-env.d.ts

@@ -0,0 +1,3 @@
+export declare const SKILL_BACKEND_ENV_NAMES: readonly ["CREWX_APP_INSTANCE_ID", "CREWX_THREAD_ID"];
+export type SkillBackendEnvName = (typeof SKILL_BACKEND_ENV_NAMES)[number];
+export declare function isSkillBackendEnv(value: unknown): value is readonly SkillBackendEnvName[];

package/dist/app/content-media-types.d.ts

@@ -0,0 +1,2 @@
+export declare const UI_CONTENT_MEDIA_TYPES: readonly ["text/plain", "application/json"];
+export type UiContentMediaType = (typeof UI_CONTENT_MEDIA_TYPES)[number];

package/dist/app/context.d.ts

@@ -0,0 +1,2 @@
+import type { AppContext } from './app.js';
+export declare function readAppContext(env?: NodeJS.ProcessEnv): AppContext | undefined;

package/dist/app/entry.d.ts

@@ -0,0 +1,7 @@
+import type { JsonObject } from './app.js';
+export interface AppEntryOptions {
+    readonly sanitize?: (value: unknown) => unknown;
+    readonly emptyState?: JsonObject;
+    readonly inputFd?: number;
+}
+export declare function runAppEntry(importApp: () => Promise<unknown>, options?: AppEntryOptions): Promise<void>;

package/dist/app/frame.d.ts

@@ -0,0 +1,56 @@
+import type { ContentRange, ContentRangeRequest, JsonObject } from './app.js';
+import type { UiContentMediaType } from './protocol.js';
+export declare const V1_MAX_INPUT_BYTES: number;
+export declare const MAX_REQUEST_BYTES: number;
+export type RequestFrame = {
+    readonly kind: 'v1';
+    readonly value: unknown;
+} | {
+    readonly kind: 'v2';
+    readonly header: JsonObject;
+    readonly body: Uint8Array;
+} | {
+    readonly kind: 'invalid';
+};
+export declare function readStdinBytes(fd: number, maxBytes: number): Uint8Array | undefined;
+export declare function readRequestFrame(fd: number): RequestFrame;
+export declare function parseRequestFrame(bytes: Uint8Array | undefined): RequestFrame;
+export interface ContentRequest {
+    readonly in?: {
+        readonly mediaType: UiContentMediaType;
+        readonly text: string;
+    };
+    readonly out?: {
+        readonly mediaType: UiContentMediaType;
+        readonly range?: ContentRangeRequest;
+    };
+}
+export interface VerifiedFrame {
+    readonly actionId: string;
+    readonly input: JsonObject;
+    readonly state: JsonObject;
+    readonly content: ContentRequest;
+}
+export interface FrameFailure {
+    readonly code: string;
+    readonly outcome: 'failed' | 'rejected';
+}
+export declare function verifyRequestFrame(header: JsonObject, body: Uint8Array): VerifiedFrame | FrameFailure;
+export declare function isFrameFailure(value: VerifiedFrame | FrameFailure): value is FrameFailure;
+export interface DeclaredContent {
+    readonly in?: {
+        readonly mediaType: UiContentMediaType;
+        readonly required?: boolean;
+    };
+    readonly out?: {
+        readonly mediaType: UiContentMediaType;
+        readonly range?: boolean;
+    };
+}
+export declare function checkAgainstDeclaration(declared: DeclaredContent | undefined, request: ContentRequest): FrameFailure | undefined;
+export interface AnswerContent {
+    readonly body: Uint8Array;
+    readonly range?: ContentRange;
+}
+export declare function encodeResponseFrame(header: JsonObject, answer?: AnswerContent): Uint8Array;
+export declare function answerLimitFailure(answer: AnswerContent): FrameFailure | undefined;

package/dist/app/index.d.ts

@@ -0,0 +1,10 @@
+export { AppError, CrewXApp, Tool, generateManifest, generateToolDeclarations, getToolDeclarations, } from './app.js';
+export type { AppContext, AppDefinition, AppErrorContext, AppErrorMapping, AppErrorOptions, AppFailureOutcome, AppRuntimeOptions, ContentRange, ContentRangeRequest, CrewXAppConstructor, DeepReadonly, JsonObject, JsonSchema, ToolContent, ToolContentDeclaration, ToolContentInput, ToolContentOutput, ToolDeclaration, ToolOptions, ToolResult, } from './app.js';
+export { readAppContext } from './context.js';
+export { APP_TOOLS_FILE, APP_TOOLS_SCHEMA_VERSION, APP_TOOL_ENTRY } from './tool-mode.js';
+export { SKILL_BACKEND_ENV_NAMES, isSkillBackendEnv } from './backend-env.js';
+export type { SkillBackendEnvName } from './backend-env.js';
+export { executeAppRequest, runSkillApp } from './runtime.js';
+export type { AppFailureInfo, RunSkillAppOptions } from './runtime.js';
+export { runAppEntry } from './entry.js';
+export type { AppEntryOptions } from './entry.js';