@salsita-ai/sdk 0.0.0-stage → 0.49.0-develop.cbee856178

package/dist/legacy/webhook-cli/commands/build.d.ts

@@ -0,0 +1,20 @@
+interface BuildCommandOptions {
+    config?: string;
+    experimental?: boolean;
+    /**
+     * Skip overriding NODE_ENV to 'production'.
+     * This is a bit hacky - webhook build historically set NODE_ENV=production globally,
+     * which polluted process.env for subsequent operations (like Vite dev config).
+     * In dev mode, we set NODE_ENV=development early and skip the override here
+     * to keep it consistent throughout the dev session.
+     */
+    skipNodeEnvOverride?: boolean;
+    webhookEntryPoint?: string;
+    readonly preserveExistingOutput?: boolean;
+}
+/**
+ * Standalone handler for building webhooks
+ * Can be called programmatically without yargs
+ */
+export declare const runBuildCommand: ({ config, experimental, skipNodeEnvOverride, webhookEntryPoint, preserveExistingOutput, }?: BuildCommandOptions) => Promise<void>;
+export {};

package/dist/legacy/webhook-cli/commands/build.js

@@ -0,0 +1 @@
+import{resolve as o}from"path";import*as i from"process";import{build as r}from"../lib/build.js";import{loadConfig as t}from"../lib/load-config-file.js";export const runBuildCommand=async({config:l,experimental:m=!1,skipNodeEnvOverride:a=!1,webhookEntryPoint:n,preserveExistingOutput:s=!1}={})=>{a||(i.env.NODE_ENV="production");let{outDir:e,bundleName:p,entryPoint:d,readRuntimeConfig:c}=await t({config:l,experimental:m,webhookEntryPoint:n});await r({outDir:e,bundleName:p,entryPoint:d,readRuntimeConfig:c,preserveExistingOutput:s}),console.log(`Webhooks bundled to ${o(e,p)}`)};

package/dist/legacy/webhook-cli/commands/dev.d.ts

@@ -0,0 +1,37 @@
+interface DevCommandOptions {
+    config?: string;
+    experimental?: boolean;
+    debug?: boolean;
+}
+/**
+ * Standalone handler for webhook dev mode
+ * Can be called programmatically without yargs
+ * Returns the esbuild context for cleanup
+ */
+export declare const runDevCommand: ({ config, experimental, debug }?: DevCommandOptions) => Promise<{
+    rebuild(): Promise<import("esbuild").BuildResult<{
+        entryPoints: string[];
+        logLevel: "error" | "info";
+        bundle: true;
+        outfile: string;
+        platform: "node";
+        target: string;
+        format: "cjs";
+        jsx: "automatic";
+        treeShaking: true;
+        loader: {
+            '.html': "text";
+        };
+        tsconfigRaw: {};
+        define: {
+            'phx.webhooksEnv': string;
+        };
+        sourcemap: true;
+        plugins: import("esbuild").Plugin[];
+    }>>;
+    watch(options?: import("esbuild").WatchOptions): Promise<void>;
+    serve(options?: import("esbuild").ServeOptions): Promise<import("esbuild").ServeResult>;
+    cancel(): Promise<void>;
+    dispose: () => Promise<void>;
+}>;
+export {};

package/dist/legacy/webhook-cli/commands/dev.js

@@ -0,0 +1 @@
+import*as o from"process";import{dev as e}from"../lib/dev.js";import{loadConfig as r}from"../lib/load-config-file.js";export const runDevCommand=async({config:t,experimental:i=!1,debug:m=!1}={})=>{o.env.NODE_ENV="development";let{entryPoint:n,outDir:s,bundleName:a,port:l,handler:p,verbosity:f,readRuntimeConfig:v}=await r({config:t,experimental:i});return e({entryPoint:n,outDir:s,bundleName:a,handler:p,port:l,verbosity:m?f:3,readRuntimeConfig:v,debug:m})};

package/dist/legacy/webhook-cli/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { runBuildCommand } from './build.js';
+export { runDevCommand } from './dev.js';
+export { runStartCommand } from './start.js';

package/dist/legacy/webhook-cli/commands/index.js

@@ -0,0 +1 @@
+export{runBuildCommand}from"./build.js";export{runDevCommand}from"./dev.js";export{runStartCommand}from"./start.js";

package/dist/legacy/webhook-cli/commands/start.d.ts

@@ -0,0 +1,11 @@
+interface StartCommandOptions {
+    config?: string;
+    experimental?: boolean;
+    port?: number;
+}
+/**
+ * Standalone handler for starting webhook server
+ * Can be called programmatically without yargs
+ */
+export declare const runStartCommand: ({ config, experimental, port: portOverride, }?: StartCommandOptions) => Promise<import("../lib/start.js").ServerHandle>;
+export {};

package/dist/legacy/webhook-cli/commands/start.js

@@ -0,0 +1 @@
+import{resolve as t}from"path";import{loadConfig as r}from"../lib/load-config-file.js";import{start as o}from"../lib/start.js";export const runStartCommand=async({config:a,experimental:i=!1,port:m}={})=>{let{outDir:n,bundleName:p,port:l,handler:e,verbosity:f}=await r({config:a,experimental:i});return o({bundle:t(n,p),port:m??l,handler:e,verbosity:f})};

package/dist/legacy/webhook-cli/index.d.ts

@@ -0,0 +1,4 @@
+export { runBuildCommand } from './commands/build.js';
+export { loadConfig } from './lib/load-config-file.js';
+export { execute, getLogger, setLogger as setLambdaLocalLogger } from './lambda-local/index.js';
+export { webhookLogContext } from './lambda-local/log-context.js';

package/dist/legacy/webhook-cli/index.js

@@ -0,0 +1 @@
+export{runBuildCommand}from"./commands/build.js";export{loadConfig}from"./lib/load-config-file.js";export{execute,getLogger,setLogger as setLambdaLocalLogger}from"./lambda-local/index.js";export{webhookLogContext}from"./lambda-local/log-context.js";

package/dist/legacy/webhook-cli/lambda-local/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This whole module (submodules) are forked from https://www.npmjs.com/package/lambda-local
+ * and patched so they work for our purposes.
+ * We are not using patch as we need to publish this code and patching in projects is not a good idea.
+ */
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const version = "2.2.0";
+export declare function setLogger(_logger: any): void;
+export declare function getLogger(): Console;
+export declare function execute(opts: any): Promise<unknown> | undefined;
+export declare function watch(opts: any): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/legacy/webhook-cli/lambda-local/index.js

@@ -0,0 +1 @@
+import dotenv from"dotenv";import fs from"fs";import{createServer}from"http";import{createRequire}from"module";import os from"os";import path from"path";import Context from"./lib/context.js";import{installLambdaStreaming}from"./lib/streaming.js";import*as utils from"./lib/utils.js";import{webhookLogContext}from"./log-context.js";installLambdaStreaming();let require=createRequire(import.meta.url);export const version="2.2.0";var logger=utils.getWinstonConsole();export function setLogger(e){null!=e&&void 0!==e.transports?logger=e:console.warn("Invalid logger object ! Using default logger")}export function getLogger(){return logger}export function execute(e){if(e.callback)_executeSync.apply(this,[e]);else{var t=this;return new Promise(function(o,n){var r=Object.assign({},e);r.callback=function(e,t){e&&n(e),o(t)},_executeSync.apply(t,[r])})}}export function watch(e){e.verboseLevel||(e.verboseLevel=0);let t=createServer(async function(e,t){return webhookLogContext.run("webhook",async()=>o(e,t))});async function o(t,o){let n=t.method,r=t.url;function a(e){return logger.log("warn",`⚠️  ${n} ${r} => `,e),o.statusCode=500,o.end(JSON.stringify({error:e}))}try{_getRequestPayload(t,async(t,s)=>{try{if(t)throw t;let a=await execute({...e,event:s}),i=_formatResponsePayload(o,a);return e.verboseLevel>0&&logger.log("info",`✓ ${n} ${r}`),o.end(i)}catch(e){return a(e)}})}catch(e){return a(e)}}return t.listen(e.port,function(){logger.log("info",`ℹ️  Lambda handler ready on http://localhost:${e.port}`)}),t}function _getRequestPayload(e,t){let o="";e.on("data",e=>{o+=e.toString()}),e.on("end",()=>{let n,r,a="application/json"!==e.headers["content-type"];try{n=a?o:Buffer.from(o,"utf-8").toString("base64")}catch(e){t(e);return}if(n.event)r=n.event;else{let t=new URL(e.url,`http://${e.headers.host}`);r={version:"2.0",routeKey:"$default",rawPath:t.pathname,rawQueryString:t.search,cookies:utils.parseCookies(e),headers:e.headers,queryStringParameters:Object.fromEntries(t.searchParams),requestContext:{accountId:"123456789012",apiId:"api-id",authentication:{},authorizer:{},http:{method:e.method,path:t.pathname,protocol:"HTTP/"+e.httpVersion,sourceIp:e.socket.localAddress,userAgent:e.headers["user-agent"]},requestId:"id",routeKey:"$default",stage:"$default",time:new Date().toISOString(),timeEpoch:new Date().getTime()},body:n,isBase64Encoded:!a}}t(null,r)})}function _formatResponsePayload(e,t){return t.statusCode||(t={isBase64Encoded:!1,statusCode:200,body:t,headers:{"content-type":"application/json"}}),e.writeHead(t.statusCode,t.headers),t.body}function updateEnv(e){Object.keys(e).forEach(function(t){process.env[t]||(process.env[t]=e[t])})}function _executeSync(opts){var event=opts.event,lambdaFunc=opts.lambdaFunc,lambdaPath=opts.lambdaPath,lambdaHandler=opts.lambdaHandler||"handler",esm=opts.esm,profilePath=opts.profilePath,profileName=opts.profileName||process.env.AWS_PROFILE||process.env.AWS_DEFAULT_PROFILE,region=opts.region,environment=opts.environment,envdestroy=opts.envdestroy,envfile=opts.envfile,callbackWaitsForEmptyEventLoop=opts.callbackWaitsForEmptyEventLoop||!1,timeoutMs=opts.timeoutMs||1e4,verboseLevel=opts.verboseLevel,callback=opts.callback,contextOverwrite=opts.contextOverwrite,onInvocationEnd=opts.onInvocationEnd,clientContext=null;if(opts.clientContext)if("string"==typeof opts.clientContext)try{clientContext=JSON.parse(opts.clientContext)}catch(err){throw SyntaxError("clientContext is an invalid stringified JS object")}else clientContext=opts.clientContext;if(lambdaFunc&&lambdaPath)throw SyntaxError("Cannot specify both lambdaFunc and lambdaPath !");callbackWaitsForEmptyEventLoop&&16>utils.get_node_major_version()&&(console.warn("callbackWaitsForEmptyEventLoop not supported on node < 16"),callbackWaitsForEmptyEventLoop=!1),lambdaPath&&(lambdaPath=(esm&&"win32"===process.platform?"file://":"")+utils.getAbsolutePath(lambdaPath));var envVars={AWS_LAMBDA_FUNCTION_NAME:lambdaHandler,AWS_LAMBDA_FUNCTION_MEMORY_SIZE:Math.floor(os.freemem()/1048576).toString(),AWS_LAMBDA_FUNCTION_VERSION:"1.0",AWS_EXECUTION_ENV:"AWS_Lambda_nodejs"+process.version.substr(1),LAMBDA_CONSOLE_SOCKET:"14",LAMBDA_CONTROL_SOCKET:"11",LAMBDA_RUNTIME_DIR:process.cwd(),NODE_PATH:utils.getAbsolutePath("node_modules"),TZ:Intl.DateTimeFormat().resolvedOptions().timeZone};lambdaPath?(envVars.LAMBDA_TASK_ROOT=path.dirname(lambdaPath),envVars._HANDLER=path.basename(lambdaPath,path.extname(lambdaPath))+"."+lambdaHandler):(envVars.LAMBDA_TASK_ROOT=process.cwd(),envVars._HANDLER="index."+lambdaHandler),updateEnv(envVars),null!=environment&&(null==envdestroy&&(envdestroy=!1),Object.keys(environment).forEach(function(e){process.env[e]=environment[e]})),null!=envfile&&dotenv.config({path:envfile,quiet:!0}),profilePath=profilePath||process.env.AWS_SHARED_CREDENTIALS_FILE;var default_config_file=utils.getAbsolutePath("~/.aws/config"),default_credentials_file=utils.getAbsolutePath("~/.aws/credentials");fs.existsSync(default_config_file)&&utils.loadAWSCredentials(default_config_file,profileName),fs.existsSync(default_credentials_file)&&utils.loadAWSCredentials(default_credentials_file,profileName),profilePath&&utils.loadAWSCredentials(profilePath,profileName),process.env.AWS_REGION=region||process.env.AWS_REGION||"us-east-1",process.env.AWS_DEFAULT_REGION=region||process.env.AWS_DEFAULT_REGION||"us-east-1",void 0===verboseLevel&&(verboseLevel=3);var context=new Context;context._initialize({functionName:lambdaHandler,timeoutMs:timeoutMs,callbackWaitsForEmptyEventLoop:callbackWaitsForEmptyEventLoop,verboseLevel:verboseLevel,logger:logger,finalCallback:function(){null!=environment&&envdestroy&&Object.keys(environment).forEach(function(e){delete process.env[e]})},clientContext:clientContext,onInvocationEnd:onInvocationEnd}),callback&&(context.callback=callback);var ctx=context.generate_context();contextOverwrite&&opts.contextOverwrite(ctx);let executeLambdaFunc=e=>{try{event instanceof Function&&(event=event()),context._init_timeout();var t=e[lambdaHandler](event,ctx,ctx.done);t&&(t.then?t.then(ctx.succeed,ctx.fail):ctx.succeed(null))}catch(e){ctx.fail(e)}};try{lambdaFunc?executeLambdaFunc(lambdaFunc):esm?eval("import(lambdaPath)").then(executeLambdaFunc,e=>ctx.fail(e)):(delete require.cache[require.resolve(lambdaPath)],executeLambdaFunc(require(lambdaPath)))}catch(err){ctx.fail(err)}}

package/dist/legacy/webhook-cli/lambda-local/lib/context.d.ts

@@ -0,0 +1,2 @@
+declare function Context(): void;
+export default Context;

package/dist/legacy/webhook-cli/lambda-local/lib/context.js

@@ -0,0 +1 @@
+import t from"./mute.js";import{isStreamingBody as e}from"./streaming.js";import*as i from"./utils.js";function n(){this.logger=null,this.unmute=null,this.verboseLevel=null,this.finalCallback=null,this.doneStatus=!1,this.postDone=function(t,e){},this.startTime,this.timeout,this._timeout,this.callbackWaitsForEmptyEventLoop=!1,this.functionName="",this.functionVersion=process.env.AWS_LAMBDA_FUNCTION_VERSION,this.invokedFunctionArn=null,this.memoryLimitInMB=process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,this.awsRequestId=null,this.logGroupName="Group name",this.logStreamName="Stream name",this.identity=null,this.clientContext=null,this.onInvocationEnd=null,this.callback=function(t){return t}}n.prototype.createInvokeFunctionArn=function(){return["arn:aws:lambda",process.env.AWS_REGION,process.env.AWS_ACCOUNT_ID||Math.round(1e12*Math.random()).toString(),"function",this.functionName,this.functionVersion].join(":")},n.prototype._initialize=function(e){this.startTime=new Date().getTime(),this.timeout=e.timeoutMs,this.logger=e.logger,this.verboseLevel=e.verboseLevel,this.finalCallback=e.finalCallback,this.functionName=e.functionName,this.awsRequestId=[i.generateRandomHex(8),i.generateRandomHex(4),i.generateRandomHex(4),i.generateRandomHex(4),i.generateRandomHex(12)].join("-"),this.invokedFunctionArn=this.createInvokeFunctionArn(),this.callbackWaitsForEmptyEventLoop=e.callbackWaitsForEmptyEventLoop,this.verboseLevel>1&&this.logger.log("info","START RequestId: "+this.awsRequestId),this.verboseLevel<3&&this.verboseLevel>=0&&(this.unmute=t()),this.clientContext=e.clientContext,this.onInvocationEnd=e.onInvocationEnd},n.prototype._init_timeout=function(){this._timeout=setTimeout((function(){this.fail(new i.TimeoutError("Task timed out after "+(this.timeout/1e3).toFixed(2)+" seconds"))}).bind(this),this.timeout)},n.prototype.generate_context=function(){return{done:this.done.bind(this),fail:this.fail.bind(this),succeed:this.succeed.bind(this),getRemainingTimeInMillis:this.getRemainingTimeInMillis.bind(this),callbackWaitsForEmptyEventLoop:this.callbackWaitsForEmptyEventLoop,functionName:this.functionName,functionVersion:this.functionVersion,invokedFunctionArn:this.invokedFunctionArn,memoryLimitInMB:this.memoryLimitInMB,awsRequestId:this.awsRequestId,logGroupName:this.logGroupName,logStreamName:this.logStreamName,identity:this.identity,clientContext:this.clientContext,_stopped:!1,__lambdaLocal:{onInvocationEnd:this.onInvocationEnd}}},n.prototype.done=function(t,n){if(!this._stopped){if(this._stopped=!0,clearTimeout(this._timeout),null!=this.unmute&&(this.unmute(),this.unmute=null),t instanceof Error){var o;if(t.stack){(o=t.stack.split("\n")).shift();for(var s=0;s<o.length;s++)o[s]=o[s].trim().substr(3);t={errorMessage:t.message,errorType:t.name,stackTrace:o}}else t={errorMessage:t.message,errorType:t.name}}if(null!=t?(this.verboseLevel>1&&this.logger.log("error","End - Error:"),this.verboseLevel>0&&this.logger.log("error",i.processJSON(t))):(this.verboseLevel>1&&this.logger.log("info","End - Result:"),this.verboseLevel>0&&this.logger.log("info",i.processJSON(n))),this.finalCallback(),"object"==typeof n&&e(n?.body)||this.onInvocationEnd?.(),this.callbackWaitsForEmptyEventLoop){var r=this;i.waitForNodeJS(function(){r.callback(t,n)})}else this.callback(t,n)}},n.prototype.fail=function(t){this.done(t)},n.prototype.succeed=function(t){this.done(null,t)},n.prototype.getRemainingTimeInMillis=function(){var t=new Date().getTime();return this.timeout+this.startTime-t};export default n;

package/dist/legacy/webhook-cli/lambda-local/lib/mute.d.ts

@@ -0,0 +1 @@
+export default function (): () => void;

package/dist/legacy/webhook-cli/lambda-local/lib/mute.js

@@ -0,0 +1 @@
+function r(r){var t=r&&r.write,i=t&&t.originalWrite;function o(){}t&&!i&&(o.originalWrite=t,r.write=o)}function t(r){var t=r&&r.write,i=t&&t.originalWrite;t&&i&&(r.write=i)}Array.prototype.concat;export default function(){var i=[process.stdout,process.stderr];return i.forEach(r),function(){i.forEach(t)}}

package/dist/legacy/webhook-cli/lambda-local/lib/streaming.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Implements Lambda Response Streaming by polyfilling
+ * `awslambda.streamifyResponse` and `awslambda.HttpResponseStream.from`.
+ *
+ * If they're used, `execute` will return a `ReadableStream` as `body`.
+ *
+ * See https://aws.amazon.com/fr/blogs/compute/introducing-aws-lambda-response-streaming/ for reference.
+ */
+import { PassThrough } from 'stream';
+declare const streamingBodyMarker: unique symbol;
+export declare const isStreamingBody: (value: unknown) => boolean;
+export declare class StreamingBody extends PassThrough {
+    private readonly resolve;
+    readonly [streamingBodyMarker] = true;
+    constructor(resolve: (metadata: any) => void);
+    headersSent: boolean;
+    sendHeader(metadata?: any): void;
+    private contentType;
+    setContentType(contentType: any): void;
+}
+export declare const installLambdaStreaming: () => void;
+export {};

package/dist/legacy/webhook-cli/lambda-local/lib/streaming.js

@@ -0,0 +1 @@
+import{PassThrough as e}from"stream";let t=Symbol.for("salsita.phoenix.lambda-streaming-body");export const isStreamingBody=n=>n instanceof e&&!0===n[t];function n(e){return(t,n)=>new Promise(async(a,o)=>{let s=new StreamingBody(a);try{let a=await e(t,s,n);s.headersSent||s.sendHeader(a),n.__lambdaLocal.onInvocationEnd?.()}catch(e){o(e),n.__lambdaLocal.onInvocationEnd?.(e)}})}export class StreamingBody extends e{resolve;[t]=!0;constructor(e){super(),this.resolve=e}headersSent=!1;sendHeader(e={}){let t={...e.headers};this.contentType&&(t["Content-Type"]=this.contentType),this.resolve({...e,headers:t,body:this}),this.headersSent=!0}contentType;setContentType(e){this.contentType=e}}let a=class HttpResponseStream{static from(e,t){return e.sendHeader(t),e}};export const installLambdaStreaming=()=>{global.awslambda=global.awslambda||{streamifyResponse:n,HttpResponseStream:a}};

package/dist/legacy/webhook-cli/lambda-local/lib/utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * utility functions
+ */
+export declare function get_node_major_version(): number;
+export declare function generateRandomHex(length: any): string;
+export declare function getWinstonConsole(): Console;
+export declare function getAbsolutePath(path: any): any;
+export declare function processJSON(json: any): any;
+export declare function parseCookies(request: any): {};
+export declare class TimeoutError extends Error {
+    constructor(m: string);
+}
+export declare function loadAWSCredentials(path: string, profileName?: string): void;
+export declare function waitForNodeJS(cb: any, i?: number): void;

package/dist/legacy/webhook-cli/lambda-local/lib/utils.js

@@ -0,0 +1 @@
+import e from"fs";import t from"path";import r from"util";let o=t.join;export function get_node_major_version(){return parseInt(process.version.slice(1).split(".")[0])}let n="0123456789abcdef".split("");export function generateRandomHex(e){for(var t="",r=0;r<e;r++)t+=n[Math.floor(Math.random()*n.length)];return t}export function getWinstonConsole(){return console}export function getAbsolutePath(e){var t=process.env.HOME||process.env.USERPROFILE;return e.match(/^\//)||e.match(/([A-Z|a-z]:\\[^*|"<>?\n]*)|(\\\\.*?\\.*)/)?e:"~"===e?t:"~/"===e.slice(0,2)?o(t,e.slice(2)):"./"===e.slice(0,2)?o(process.cwd(),e.slice(2)):o(process.cwd(),e)}export function processJSON(e){if("object"!=typeof e)return e;try{return JSON.stringify(e,null,"	")}catch(t){return r.inspect(e)}}export function parseCookies(e){let t={},r=e.headers?.cookie;return r&&r.split(";").forEach(function(e){let[r,...o]=e.split("=");if(!(r=r?.trim()))return;let n=o.join("=").trim();n&&(t[r]=decodeURIComponent(n))}),t}export class TimeoutError extends Error{constructor(e){super(e),this.name="TimeoutError"}}var s=function(e,t,r,o){if(!process.env[t]){var n;null!==(n=RegExp("\\["+o+"\\](.|\\n|\\r\\n)*?"+e+"( ?)+=( ?)+(.*)").exec(r))&&(process.env[t]=n[4])}};export function loadAWSCredentials(t,r="default"){var o=e.readFileSync(getAbsolutePath(t)).toString();s("aws_secret_access_key","AWS_SECRET_ACCESS_KEY",o,r),s("aws_access_key_id","AWS_ACCESS_KEY_ID",o,r),s("aws_session_token","AWS_SESSION_TOKEN",o,r),s("metadata_service_timeout","AWS_METADATA_SERVICE_TIMEOUT",o,r),s("metadata_service_num_attempts","AWS_METADATA_SERVICE_NUM_ATTEMPTS",o,r),s("region","AWS_REGION",o,r)}export function waitForNodeJS(e,t=0){process.getActiveResourcesInfo().filter(e=>"Timeout"===e).length>t?setTimeout(function(){waitForNodeJS(e,t=1)},100):e()}

package/dist/legacy/webhook-cli/lambda-local/log-context.d.ts

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Carries webhook attribution across the async work triggered by a local
+ * webhook invocation. The phoenix dev command patches the global console and
+ * uses this store to attribute user-handler output to the webhook log stream;
+ * everything outside an invocation stays unattributed.
+ */
+export declare const webhookLogContext: AsyncLocalStorage<"webhook">;

package/dist/legacy/webhook-cli/lambda-local/log-context.js

@@ -0,0 +1 @@
+import{AsyncLocalStorage as o}from"node:async_hooks";export const webhookLogContext=new o;

package/dist/legacy/webhook-cli/lib/build.d.ts

@@ -0,0 +1,33 @@
+import * as esbuild from 'esbuild';
+export interface BuildOptions {
+    entryPoint: string;
+    bundleName: string;
+    outDir: string;
+    readRuntimeConfig: () => Record<string, unknown>;
+    debug?: boolean;
+    readonly preserveExistingOutput?: boolean;
+}
+export interface WatchOptions extends BuildOptions {
+    onRebuilt: () => Promise<void> | void;
+}
+export declare const build: (options: BuildOptions) => Promise<void>;
+export declare const watch: (options: WatchOptions) => Promise<esbuild.BuildContext<{
+    entryPoints: string[];
+    logLevel: "error" | "info";
+    bundle: true;
+    outfile: string;
+    platform: "node";
+    target: string;
+    format: "cjs";
+    jsx: "automatic";
+    treeShaking: true;
+    loader: {
+        '.html': "text";
+    };
+    tsconfigRaw: {};
+    define: {
+        'phx.webhooksEnv': string;
+    };
+    sourcemap: true;
+    plugins: esbuild.Plugin[];
+}>>;

package/dist/legacy/webhook-cli/lib/build.js

@@ -0,0 +1 @@
+import*as e from"esbuild";import{ensureDir as t,remove as o}from"fs-extra";import{writeFile as r}from"fs/promises";import a from"lodash-es/debounce.js";import{resolve as i}from"path";import{printBuildReport as n}from"./report-utils.js";import{isClientAssetImport as s,isClientOnlySdkImport as l}from"./webhook-boundary.js";let p=async e=>{let t=i(e);await o(t)},m=async(e,o)=>{let a=JSON.stringify({name:"webhooks",type:"commonjs",main:o},null,2);await t(e),await r(i(e,"package.json"),a,"utf8")},u={name:"webhook-client-code-guard",setup:e=>{e.onResolve({filter:/.*/},e=>l(e.path)?{errors:[{text:`"${e.path}" is a client-only SDK entrypoint and cannot be part of the webhook (server) bundle.`,notes:[{text:`Imported by ${e.importer}. Move the client-only import out of code the webhook bundles, or split the file.`}]}]}:s(e.path)?{errors:[{text:`"${e.path}" is a style/asset import and cannot be part of the webhook (server) bundle.`,notes:[{text:`Imported by ${e.importer}. Move the import out of code the webhook bundles, or split the file.`}]}]}:void 0)}},h=({entryPoint:t,bundleName:o,outDir:r,onRebuilt:n,readRuntimeConfig:s,debug:l})=>{let p=a(console.log,500);return e.context({entryPoints:[t],logLevel:l?"info":"error",bundle:!0,outfile:i(r,o),platform:"node",target:"es2020",format:"cjs",jsx:"automatic",treeShaking:!0,loader:{".html":"text"},tsconfigRaw:{},define:{"phx.webhooksEnv":JSON.stringify(s())},sourcemap:!0,plugins:[u,{name:"on-rebuilt",setup:e=>{e.onEnd(async e=>{0!==e.errors.length||l||p("✅ Webhooks ready"),n&&await n()})}}]})};export const build=async e=>{e.preserveExistingOutput||await p(e.outDir);let t=await h(e);try{await m(e.outDir,e.bundleName),(await t.rebuild()).errors.length||await n(e.outDir,e.bundleName,"Webhook Bundle Report")}finally{await t.dispose()}};export const watch=async e=>{let t=await h(e);return await m(e.outDir,e.bundleName),await t.watch(),t};

package/dist/legacy/webhook-cli/lib/config-file.d.ts

@@ -0,0 +1,41 @@
+export interface CliConfig {
+    /**
+     * Path to the entry point of the webhooks source code.
+     * @default 'src/index.ts'
+     */
+    entryPoint: string;
+    /**
+     * Path to the output directory.
+     * The directory will be created if it does not exist, and it will be emptied before the build.
+     * @default 'dist'
+     */
+    outDir: string;
+    /**
+     * File name of the bundled webhooks source code. (without the path)
+     * @default 'webhooks.js'
+     */
+    bundleName: string;
+    /**
+     * The exported function to invoke as a Lambda handler.
+     * @default 'handler'
+     */
+    handler: string;
+    /**
+     * The port the local server will listen on.
+     * @default 8080
+     */
+    port: number;
+    /**
+     * Level of verbosity of the local server logs: 0 = URLs, 1 = + response, 2 = + internal output, 3 = + lambda output
+     * @default 3
+     */
+    verbosity: number;
+    /**
+     * Function to read the runtime configuration from the environment variables.
+     * The returned object will be available in the `phx.webhooksEnv` variable.
+     * Note that the returned object must be serializable to JSON.
+     * @default () => ({})
+     */
+    readRuntimeConfig: () => Record<string, unknown>;
+}
+export type UserConfig = Partial<CliConfig>;

package/dist/legacy/webhook-cli/lib/config-file.js

@@ -0,0 +1 @@
+export{};

package/dist/legacy/webhook-cli/lib/dev.d.ts

@@ -0,0 +1,33 @@
+import type { BuildOptions } from './build.js';
+export interface DevOptions extends BuildOptions {
+    handler: string;
+    port: number;
+    verbosity: number;
+    debug?: boolean;
+}
+export declare const dev: ({ entryPoint, bundleName, outDir, readRuntimeConfig, debug, ...serverOptions }: DevOptions) => Promise<{
+    rebuild(): Promise<import("esbuild").BuildResult<{
+        entryPoints: string[];
+        logLevel: "error" | "info";
+        bundle: true;
+        outfile: string;
+        platform: "node";
+        target: string;
+        format: "cjs";
+        jsx: "automatic";
+        treeShaking: true;
+        loader: {
+            '.html': "text";
+        };
+        tsconfigRaw: {};
+        define: {
+            'phx.webhooksEnv': string;
+        };
+        sourcemap: true;
+        plugins: import("esbuild").Plugin[];
+    }>>;
+    watch(options?: import("esbuild").WatchOptions): Promise<void>;
+    serve(options?: import("esbuild").ServeOptions): Promise<import("esbuild").ServeResult>;
+    cancel(): Promise<void>;
+    dispose: () => Promise<void>;
+}>;

package/dist/legacy/webhook-cli/lib/dev.js

@@ -0,0 +1 @@
+import{resolve as t}from"path";import{watch as a}from"./build.js";import{start as o}from"./start.js";export const dev=async({entryPoint:i,bundleName:s,outDir:r,readRuntimeConfig:p,debug:e,...n})=>{let d,m=await a({entryPoint:i,outDir:r,bundleName:s,readRuntimeConfig:p,debug:e,onRebuilt:async()=>{d&&await d.stop(),d=await o({...n,bundle:t(r,s)})}});return{...m,dispose:async()=>{d&&(await d.stop(),d=void 0),await m.dispose()}}};

package/dist/legacy/webhook-cli/lib/import-ts-file.d.ts

@@ -0,0 +1 @@
+export declare const importTsFile: <EXPORTS>(fileName: string) => Promise<EXPORTS>;

package/dist/legacy/webhook-cli/lib/import-ts-file.js

@@ -0,0 +1 @@
+import{build as t}from"esbuild";import{unlink as r}from"fs/promises";import{pathToFileURL as o}from"url";export const importTsFile=async e=>{let i=`${e}-${Date.now()}-${Math.random().toString(16).slice(2)}`,a=`${i}.mjs`,m=`${o(i)}.mjs`;await t({entryPoints:[e],target:["node20"],platform:"node",bundle:!0,outfile:a,format:"esm",external:["*"]});try{return await import(m)}finally{await r(a)}};

package/dist/legacy/webhook-cli/lib/load-config-file.d.ts

@@ -0,0 +1,7 @@
+import type { CliConfig } from './config-file.js';
+export interface LoadConfigOptions {
+    readonly config?: string;
+    readonly experimental?: boolean;
+    readonly webhookEntryPoint?: string;
+}
+export declare const loadConfig: (options?: LoadConfigOptions) => Promise<CliConfig>;

package/dist/legacy/webhook-cli/lib/load-config-file.js

@@ -0,0 +1 @@
+import{existsSync as o}from"fs";import{resolve as e}from"path";import{importTsFile as i}from"./import-ts-file.js";export const loadConfig=async(t={})=>{let{config:n,experimental:r=!1}=t,s=e(r?"./.phoenix":".","webhooks.config.ts"),d=n??(o(s)?s:void 0),f=(({experimental:o=!1,webhookEntryPoint:e})=>({outDir:o?"./.phoenix/dist/webhooks":"dist",bundleName:"webhooks.js",port:8080,handler:"handler",entryPoint:e??(o?"./.phoenix/.swc/.phoenix/webhooks/index.js":"src/index.ts"),verbosity:3,readRuntimeConfig:()=>({})}))(t);if(!d)return f;{let o=await i(d);return{...f,...o.default}}};

package/dist/legacy/webhook-cli/lib/report-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Format bytes to human-readable size string
+ */
+export declare const formatSize: (bytes: number) => string;
+/**
+ * Print a detailed build report for a bundle file
+ */
+export declare const printBuildReport: (outDir: string, bundleName: string, title?: string) => Promise<void>;

package/dist/legacy/webhook-cli/lib/report-utils.js

@@ -0,0 +1,2 @@
+import{readFile as o,stat as e}from"fs/promises";import{relative as r,resolve as t}from"path";import{gzipSync as l}from"zlib";export const formatSize=o=>o<1024?`${o} B`:o<1048576?`${(o/1024).toFixed(2)} kB`:`${(o/1048576).toFixed(2)} MB`;export const printBuildReport=async(i,n,s="Bundle Report")=>{let a=t(i,n),p=r(process.cwd(),a);try{let r=await e(a),t=await o(a),i=l(new Uint8Array(t));console.log(`
+📦 ${s}:`),console.log("┌─────────────────────────────────────────────────────────┐"),console.log(`│ File: ${p.padEnd(46)} │`),console.log("├─────────────────────────────────────────────────────────┤"),console.log(`│ Size:     ${formatSize(r.size).padEnd(43)} │`),console.log(`│ Gzipped:  ${formatSize(i.length).padEnd(43)} │`),console.log("└─────────────────────────────────────────────────────────┘")}catch(o){console.error(`Failed to generate ${s.toLowerCase()}:`,o)}};

package/dist/legacy/webhook-cli/lib/server-options.d.ts

@@ -0,0 +1,6 @@
+export interface ServerOptions {
+    readonly bundle: string;
+    readonly handler: string;
+    readonly port: number;
+    readonly verbosity: number;
+}

package/dist/legacy/webhook-cli/lib/server-options.js

@@ -0,0 +1 @@
+export{};

package/dist/legacy/webhook-cli/lib/start.d.ts

@@ -0,0 +1,6 @@
+import type { ServerOptions } from './server-options.js';
+export interface ServerHandle {
+    readonly stop: () => Promise<void>;
+    readonly stopped: Promise<void>;
+}
+export declare const start: (options: ServerOptions) => Promise<ServerHandle>;

package/dist/legacy/webhook-cli/lib/start.js

@@ -0,0 +1 @@
+import{watch as e}from"../lambda-local/index.js";export const start=async o=>{let l=e({lambdaPath:o.bundle,lambdaHandler:o.handler,esm:!1,port:o.port,verboseLevel:o.verbosity});await new Promise((e,o)=>{let r=()=>{l.off("error",t),e()},t=e=>{l.off("listening",r),o(e)};l.once("listening",r),l.once("error",t)});let r=new Promise(e=>{l.once("close",e)}),t=null;return{stop:()=>{if(t)return t;l.close();let e=setTimeout(()=>{l.closeAllConnections()},3e3);return t=r.finally(()=>{clearTimeout(e)})},stopped:r}};

package/dist/legacy/webhook-cli/lib/webhook-boundary.d.ts

@@ -0,0 +1,2 @@
+export declare const isClientOnlySdkImport: (specifier: string) => boolean;
+export declare const isClientAssetImport: (specifier: string) => boolean;

package/dist/legacy/webhook-cli/lib/webhook-boundary.js

@@ -0,0 +1 @@
+let t=/^@salsita-ai\/sdk\/(admin|application|react|configurator|ui|editor|extras\/clerk)(\/|$)/,s=/\.(css|scss|sass|less|woff2?|ttf|otf|eot|png|jpe?g|gif|svg|webp|avif)(\?.*)?$/i;export const isClientOnlySdkImport=s=>t.test(s);export const isClientAssetImport=t=>s.test(t);

package/dist/legacy/webhook-cli/utils.d.ts

@@ -0,0 +1 @@
+export declare const fail: (error: unknown) => never;

package/dist/legacy/webhook-cli/utils.js

@@ -0,0 +1 @@
+import*as r from"process";export const fail=o=>{o instanceof Error?console.error(o.message):console.error(String(o)),r.exit(1)};

package/dist/phoenix/application-spec/application-spec-builder.d.ts

@@ -0,0 +1,68 @@
+import { GeneratedApplicationFile } from '#package/application-spec';
+import type { Application, ParseContext, ParseCount, ParseMetric, RawProjectFiles, SpecDiagnostic } from '#package/application-spec';
+import { type Logger } from '../utils/index.js';
+interface ApplicationSpecBuilderConfig {
+    readonly logger: Logger;
+    readonly sdkVersion: string;
+    readonly projectSlug: string;
+    readonly environmentSlug: string;
+    readonly cliUseWorkspace?: boolean;
+    readonly name?: string;
+    readonly description?: string;
+    readonly enableEditor: boolean;
+    readonly inlineTemplates: boolean;
+}
+export type ApplicationSpecBuildResult = {
+    readonly ok: true;
+    readonly application: Application;
+    readonly changedFiles: readonly GeneratedApplicationFile[];
+    readonly diagnostics: readonly SpecDiagnostic[];
+    readonly metrics: readonly ParseMetric[];
+    readonly counts: readonly ParseCount[];
+} | {
+    readonly ok: false;
+    readonly rawProjectFiles: RawProjectFiles;
+    readonly errors: readonly SpecDiagnostic[];
+    readonly diagnostics: readonly SpecDiagnostic[];
+    readonly metrics: readonly ParseMetric[];
+    readonly counts: readonly ParseCount[];
+};
+/**
+ * Stateful builder for the application-spec pipeline.
+ *
+ * Uses a single diff layer: generated file content is hashed and compared against
+ * what's already on disk (via lazy disk reads) + a running in-memory map. Only
+ * files whose output differs from disk get re-written and Vite-invalidated.
+ *
+ * Both one-shot builds and the dev watcher create an instance.
+ */
+export declare class ApplicationSpecBuilder {
+    private readonly contentDiff;
+    private readonly referenceStore;
+    private readonly config;
+    private readonly logger;
+    private readonly phxDefinitions;
+    constructor(config: ApplicationSpecBuilderConfig);
+    /**
+     * Run the full pipeline: read → parse → generate → content diff → write → compile.
+     *
+     * @param options.force - Treat all outputs as changed (skip disk baseline). Used when the
+     *   caller wants to guarantee a full regeneration on disk (e.g. initial deployment upload).
+     */
+    build(options?: {
+        readonly force?: boolean;
+        readonly rawProjectFiles?: RawProjectFiles;
+        readonly parsingContext?: ParseContext;
+        readonly compile?: boolean;
+    }): Promise<ApplicationSpecBuildResult>;
+    private compile;
+    private readonly readDiskContent;
+    /**
+     * Remove stale files from .phoenix/ that are not in the expected generated file set.
+     * Handles leftover files/dirs from the project-gen pipeline when switching to application-spec.
+     *
+     * TODO: remove once application-spec pipeline fully replaces project-gen
+     */
+    private cleanStaleGeneratedFiles;
+}
+export {};

package/dist/phoenix/application-spec/application-spec-builder.js

@@ -0,0 +1 @@
+import{existsSync as e,lstatSync as i,readFileSync as t,readdirSync as r,rmSync as o,unlinkSync as s}from"fs";import{join as n}from"path";import{format as l}from"prettier";import{prettierrc as a}from"@salsita-ai/common/prettier";import{GeneratedApplication as c,GeneratedApplicationFile as p,RuntimeReferenceStore as g,buildPhoenixDefinitions as f,createContentDiffTracker as h,generateApplicationCode as m,parseApplicationFiles as d}from"#package/application-spec";import{getAllPhxDefinitions as u}from"#package/domain";import{compileWithSwc as S}from"../services/swc.js";import{syncChangedFiles as b}from"../utils/index.js";import{readApplicationFiles as w}from"./application-spec-file-reader.js";import{cleanStaleAgentSkills as j,removeProjectFiles as D}from"./clean-project-files.js";import{swcEvalExpressionParser as F,swcModuleAnalyzer as x}from"./swc-module-analyzer.js";let P=".phoenix",k=`${P}/`,v=async e=>{if(e.binary||!1===e.format)return e;try{let i=await l(e.content,{...a,filepath:e.path});return p(e.path,i,{binary:e.binary,format:e.format})}catch{return e}},y=async e=>{let[i,t,r]=await Promise.all([Promise.all(e.generatedProjectFiles.map(v)),Promise.all(e.initialProjectFiles.map(v)),Promise.all(e.prettierFiles.map(v))]);return c({files:e.files,generatedProjectFiles:i,initialProjectFiles:t,prettierFiles:r,removedProjectFiles:e.removedProjectFiles})};export class ApplicationSpecBuilder{contentDiff;referenceStore;config;logger;phxDefinitions;constructor(e){this.config=e,this.logger=e.logger,this.referenceStore=new g,this.contentDiff=h({readDiskContent:this.readDiskContent}),this.phxDefinitions=f(u())}async build(e){let i=e?.parsingContext,t=e?.compile??!0;e?.force&&this.referenceStore.clear();let r=i?.startSpan("readFiles","build","application-spec-builder.ts"),o=e?.rawProjectFiles??await w({envs:{}});r?.();let s=d({rawProjectFiles:o,phxDefinitions:this.phxDefinitions},{analyzer:x,evalExpressionParser:F,referenceStore:this.referenceStore,logger:this.logger,parsingContext:i});if(!s.ok)return{ok:!1,rawProjectFiles:o,errors:s.errors,diagnostics:s.diagnostics,metrics:s.metrics,counts:s.counts};let{applicationSpec:n,categorizedFiles:l,rawMockTemplates:a}=s.value,c=i?.startSpan("generateCode","build","application-spec-builder.ts"),p=m({applicationSpec:n,categorizedFiles:l,phxDefinitions:this.phxDefinitions,sdkVersion:this.config.sdkVersion,cliUseWorkspace:this.config.cliUseWorkspace,name:this.config.name,description:this.config.description,projectSlug:this.config.projectSlug,environmentSlug:this.config.environmentSlug,enableEditor:this.config.enableEditor,inlineTemplates:this.config.inlineTemplates,rawMockTemplates:a});c?.();let g=i?.startSpan("cleanStaleFiles","build","application-spec-builder.ts"),f=new Set(p.files.map(e=>e.path));this.cleanStaleGeneratedFiles(f),D(p.removedProjectFiles,{logger:this.logger}),j(new Set(p.generatedProjectFiles.map(e=>e.path)),{logger:this.logger}),g?.();let h=i?.startSpan("contentDiff","build","application-spec-builder.ts"),u=await y(p),S=this.contentDiff.getChangedApplicationFiles(u,{generatedFilesPathPrefix:k,force:e?.force}),P=S.changedGeneratedFiles;h?.(),P.length>0?this.logger.info(`  ${P.length}/${p.files.length} generated files changed`):this.logger.info("  No generated files changed");let v=S.filesToWrite.length-P.length;v>0&&this.logger.info(`  ${v} project files changed`);let C=i?.startSpan("writeFiles","build","application-spec-builder.ts");return await b(S.filesToWrite,{logger:this.logger,skipChecksum:!0}),C?.(),t&&await this.compile(i),{ok:!0,application:s.value,changedFiles:P,diagnostics:s.diagnostics,metrics:s.metrics,counts:s.counts}}async compile(e){let i=e?.startSpan("swcCompile(src)","build","application-spec-builder.ts");await S({sourceDir:"src",outDir:`./${P}/.swc/src`},{logger:this.logger}),i?.();let t=e?.startSpan("swcCompile(.phoenix)","build","application-spec-builder.ts");await S({sourceDir:P,outDir:`./${P}/.swc/${P}`},{logger:this.logger}),t?.()}readDiskContent=i=>{try{if(e(i))return t(i,"utf-8")}catch{}};cleanStaleGeneratedFiles(t){let l=new Set(["public",".swc","dist","phoenix-dev.log","phoenix-dev.log.1","phoenix-dev.log.2"]);try{if(!e(P))return;for(let e of r(P)){if(l.has(e)||t.has(e))continue;let r=n(P,e);try{let e=i(r);if(e.isSymbolicLink())continue;e.isDirectory()?o(r,{recursive:!0}):s(r),this.logger.debug(`  Removed stale: ${r}`)}catch{}}}catch{}}}

package/dist/phoenix/application-spec/application-spec-file-reader.d.ts

@@ -0,0 +1,7 @@
+import { RawProjectFiles } from '#package/application-spec';
+/** Selects the project directory and environment values represented by a raw application-spec file set. */
+export interface ReadApplicationFilesOptions {
+    readonly projectRoot?: string;
+    readonly envs?: Record<string, unknown>;
+}
+export declare const readApplicationFiles: (options?: ReadApplicationFilesOptions) => Promise<RawProjectFiles>;

package/dist/phoenix/application-spec/application-spec-file-reader.js

@@ -0,0 +1 @@
+import{readFile as o}from"fs/promises";import{globby as r}from"globby";import{join as t}from"path";import{BinaryFile as e,RawProjectFiles as a,TextFile as i}from"#package/application-spec";import{readFrontendEnvs as s}from"../services/frontend-config.js";import{PARSED_ASSET_FILE_PATTERNS as p,PARSED_TEXT_FILE_PATTERNS as c}from"./project-files.js";let m=async e=>Promise.all((await r(c,{cwd:e})).sort().map(async r=>{let a=await o(t(e,r),"utf-8");return i(r,a)})),n=async o=>(await r(p,{cwd:o,ignore:["**/__generated/**"]})).sort().map(o=>e(o));export const readApplicationFiles=async o=>{let r=o?.projectRoot??process.cwd(),[t,e]=await Promise.all([m(r),n(r)]);return a([...t,...e],o?.envs??s())};

package/dist/phoenix/application-spec/clean-project-files.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '../utils/index.js';
+/**
+ * Where project-root cleanup runs and how it reports.
+ *
+ * `projectRoot` defaults to the working directory, which is the project root for every CLI command.
+ */
+interface CleanProjectFilesContext {
+    readonly logger: Logger;
+    readonly projectRoot?: string;
+}
+/**
+ * Delete project files that earlier SDK versions generated and the current SDK no longer emits.
+ *
+ * Cleanup is best-effort like the stale `.phoenix/` cleanup: a file that is already gone is skipped
+ * silently, and a file that cannot be deleted is reported without failing the build.
+ */
+export declare const removeProjectFiles: (paths: readonly string[], context: CleanProjectFilesContext) => void;
+/**
+ * Remove Phoenix-owned skill folders (`phoenix` and `phoenix-*`) under the agent skill roots that the
+ * current SDK no longer emits, and the files inside the surviving ones that it no longer emits.
+ *
+ * `expectedFiles` holds the project-relative paths of the generated project files; a Phoenix-owned
+ * folder survives when its `SKILL.md` is among them, and then keeps only the files among them. Skill
+ * folders with any other name belong to the project and are never touched, and symlinks are left
+ * alone as project wiring.
+ */
+export declare const cleanStaleAgentSkills: (expectedFiles: ReadonlySet<string>, context: CleanProjectFilesContext) => void;
+export {};

package/dist/phoenix/application-spec/clean-project-files.js

@@ -0,0 +1 @@
+import{existsSync as e,lstatSync as t,readdirSync as o,rmSync as i,unlinkSync as l}from"fs";import{join as r}from"path";import{agentSkillRoots as n}from"#package/application-spec";let a=e=>e instanceof Error?e.message:String(e),s=e=>"phoenix"===e||e.startsWith("phoenix-");export const removeProjectFiles=(t,o)=>{let{logger:i,projectRoot:n="."}=o;for(let o of t){let t=r(n,o);try{if(!e(t))continue;l(t),i.info(`  Removed ${o} (no longer generated by Phoenix)`)}catch(e){i.warn(`Could not remove ${o}, which Phoenix no longer generates: ${a(e)}. Delete it manually.`)}}};let c=(e,t,n)=>{let{logger:s,projectRoot:f}=n;for(let h of o(r(f,e),{withFileTypes:!0})){let m=`${e}/${h.name}`,$=r(f,m);if(!h.isSymbolicLink())try{if(h.isDirectory()){c(m,t,n),0===o($).length&&i($,{recursive:!0});continue}if(t.has(m))continue;l($),s.info(`  Removed stale Phoenix skill file ${m}`)}catch(e){s.warn(`Could not remove the stale Phoenix skill file ${m}: ${a(e)}. Delete it manually.`)}}};export const cleanStaleAgentSkills=(l,f)=>{let{logger:h,projectRoot:m="."}=f;for(let f of n){let n=r(m,f);if(e(n)&&t(n).isDirectory())for(let e of o(n)){if(!s(e))continue;let o=r(n,e);try{let r=t(o);if(r.isSymbolicLink()||!r.isDirectory())continue;if(l.has(`${f}/${e}/SKILL.md`)){try{c(`${f}/${e}`,l,{logger:h,projectRoot:m})}catch(t){h.warn(`Could not prune the stale files inside the Phoenix skill ${f}/${e}: ${a(t)}. Remove them manually.`)}continue}i(o,{recursive:!0}),h.info(`  Removed stale Phoenix skill ${f}/${e}`)}catch(t){h.warn(`Could not remove the stale Phoenix skill ${f}/${e}: ${a(t)}. Delete the folder manually.`)}}}};

package/dist/phoenix/application-spec/generate-application-spec-project.d.ts

@@ -0,0 +1,20 @@
+import { type Logger } from '../utils/index.js';
+interface GenerateProjectOptions {
+    readonly sdkVersion: string;
+    readonly projectSlug: string;
+    readonly environmentSlug: string;
+    readonly cliUseWorkspace?: boolean;
+    readonly name?: string;
+    readonly description?: string;
+    readonly enableEditor?: boolean;
+    readonly inlineTemplates?: boolean;
+    readonly withLingui?: boolean;
+    readonly force?: boolean;
+    readonly analyze?: boolean;
+    readonly logger: Logger;
+}
+export declare const generateApplicationSpecProject: (options: GenerateProjectOptions) => Promise<{
+    templateFiles: readonly string[];
+    applicationSpec: import("#package/application-spec").ApplicationSpec;
+}>;
+export {};

package/dist/phoenix/application-spec/generate-application-spec-project.js

@@ -0,0 +1,2 @@
+import{symlink as e}from"fs/promises";import{ParseContext as i}from"#package/application-spec";import{extractAndCompileLingui as t}from"../services/lingui.js";import{compileWithSwc as p}from"../services/swc.js";import{exists as a}from"../utils/index.js";import{ApplicationSpecBuilder as s}from"./application-spec-builder.js";import{formatMetrics as r}from"./metrics/index.js";import{syncTemplateFiles as n}from"./template-files.js";let o=".phoenix",c=async(e,i)=>{let t=i.startSpan("swcCompile(src)","sync","generate-application-spec-project.ts");await p({sourceDir:"src",outDir:`./${o}/.swc/src`},{logger:e}),t();let a=i.startSpan("swcCompile(.phoenix)","sync","generate-application-spec-project.ts");await p({sourceDir:o,outDir:`./${o}/.swc/${o}`},{logger:e}),a()};export const generateApplicationSpecProject=async p=>{let{withLingui:o=!0,force:l=!1,analyze:m=!1}=p,u=p.logger;u.info("Using application-spec pipeline");let g=new i,j=g.startSpan("sync","generateApplicationSpecProject","generate-application-spec-project.ts"),w=g.startSpan("build","sync","application-spec-builder.ts"),d=new s({logger:u,sdkVersion:p.sdkVersion,projectSlug:p.projectSlug,environmentSlug:p.environmentSlug,cliUseWorkspace:p.cliUseWorkspace,name:p.name,description:p.description,enableEditor:p.enableEditor??!0,inlineTemplates:p.inlineTemplates??!1}),S=await d.build({force:l,parsingContext:g,compile:!1});if(w(),!S.ok)throw Error(`Failed to parse application spec:
+${S.errors.map(e=>`  [${e.code}] ${e.message}`).join("\n")}`);let f=g.startSpan("symlink","sync","generate-application-spec-project.ts");await a("./.phoenix/public")||await e("../public","./.phoenix/public");let b=await n();if(f(),o){let e=g.startSpan("lingui","sync","generate-application-spec-project.ts");await t({logger:u}),e()}return await c(u,g),j(),m&&r(g.metrics,g.counts,u),{templateFiles:b,applicationSpec:S.application.applicationSpec}};

package/dist/phoenix/application-spec/generate-application-spec-story.d.ts

@@ -0,0 +1,10 @@
+import type { CommandContext } from '../commands/types.js';
+/**
+ * Builds one application-spec Storybook story's generated output.
+ *
+ * Reads the story's authored project, parses it, writes the story file group, and compiles the
+ * story's i18n catalogs. This is the only step that regenerates story output: while
+ * `phoenix story dev` runs, authored changes reach the editor over its WebSocket instead
+ * (`docs/architecture/story-dev.md`).
+ */
+export declare const generateApplicationSpecStory: (targetDir: string, context: CommandContext) => Promise<void>;

package/dist/phoenix/application-spec/generate-application-spec-story.js

@@ -0,0 +1,2 @@
+import{readFile as e}from"node:fs/promises";import{basename as o,join as r}from"node:path";import{GeneratedApplicationFile as a,RuntimeReferenceStore as i,buildPhoenixDefinitions as t,generateApplicationSpecStoryFiles as n,getStoryTextFiles as p,parseApplicationFiles as s}from"#package/application-spec";import{getAllPhxDefinitions as m}from"#package/domain";import{exists as c,runCommand as g,syncChangedFiles as l,toPascalCase as d}from"../utils/index.js";import{readApplicationFiles as f}from"./application-spec-file-reader.js";import{generateStoryMdxContent as u}from"./story-mdx.js";import{swcEvalExpressionParser as w,swcModuleAnalyzer as x}from"./swc-module-analyzer.js";export const generateApplicationSpecStory=async(y,j)=>{let v=await f({projectRoot:y,envs:{}}),b=p(v),h=t(m()),E=s({rawProjectFiles:v,phxDefinitions:h},{analyzer:x,evalExpressionParser:w,referenceStore:new i,logger:j.logger});if(!E.ok)throw Error(`Cannot build application-spec story because the project spec is invalid. Fix these diagnostics and rebuild:
+${E.errors.map(e=>`  [${e.code}] ${e.message}`).join("\n")}`);let S=o(y),$=d(S),k=n({application:E.value,phxDefinitions:h,rawProjectFiles:v,storyFolderName:S,storyName:$}).map(e=>a(r(y,e.path),e.content,{binary:e.binary,format:e.format})),C=r(y,`${$}.mdx`),L=await c(C)?await e(C,"utf-8"):void 0,q=a(C,u({existingMdx:L,storyName:$,textFiles:b}));await l([...k,q],{logger:j.logger}),await g({command:"npx ",args:["lingui","extract"],description:"Extracting i18n messages",quiet:!0,cwd:y,extraEnv:{LC_ALL:"en_US.UTF-8"}},{logger:j.logger}),await g({command:"npx ",args:["lingui","compile"],description:"Compiling i18n messages",quiet:!0,cwd:y},{logger:j.logger})};

package/dist/phoenix/application-spec/generate-assistant-prompt.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantSpec } from '#package/application-spec';
+/**
+ * The part of the assistant's system prompt that explains how to read the generated GraphQL schema.
+ * It is generated here, by the SDK that also runs in the browser, and stored with the deployment,
+ * because the conventions it describes belong to this SDK version and not to the server. The part
+ * about changes is left out when the schema has no `Mutation` type, the part about adding
+ * entities when it has no `addChild` mutation, the part about replacing them when it has no
+ * `replaceEntity` mutation, and the part about the choices of a field when it has
+ * no options edge. The last section explains the
+ * `query` and `apply` tools, which every run registers whatever the schema holds.
+ */
+export declare const generateAssistantPrompt: (assistant: NonNullable<AssistantSpec>) => string;