@permute/sdk 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './types.js';
 export * from './client.js';
+export { PermuteSdkBridge } from './bridge.js';
 export { Providers } from './generated/runtime-contract.js';
 export declare const Context: {
     readonly ACUMATICA: "acumatica";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './types.js';
 export * from './client.js';
+export { PermuteSdkBridge } from './bridge.js';
 export { Providers } from './generated/runtime-contract.js';
 export const Context = {
     ACUMATICA: 'acumatica',

package/dist/method.d.ts

@@ -0,0 +1,10 @@
+import type { PublicApiOperationId } from './generated/runtime-contract.js';
+type SdkMethod = (...args: never[]) => unknown;
+/** Keep route metadata on the SDK functions that execute it, without a second method registry. */
+export declare class SdkMethodFactory {
+    private static readonly operations;
+    static create<Method extends SdkMethod>(operationId: PublicApiOperationId, method: Method): Method;
+    static compose<Method extends SdkMethod>(dependencies: readonly SdkMethod[], method: Method): Method;
+    static operationsFor(method: SdkMethod): readonly PublicApiOperationId[] | undefined;
+}
+export {};

package/dist/method.js

@@ -0,0 +1,21 @@
+/** Keep route metadata on the SDK functions that execute it, without a second method registry. */
+export class SdkMethodFactory {
+    static operations = new WeakMap();
+    static create(operationId, method) {
+        this.operations.set(method, [operationId]);
+        return method;
+    }
+    static compose(dependencies, method) {
+        const operations = dependencies.flatMap((dependency) => {
+            const selected = this.operations.get(dependency);
+            if (!selected)
+                throw new Error('SDK method has no route binding.');
+            return selected;
+        });
+        this.operations.set(method, [...new Set(operations)]);
+        return method;
+    }
+    static operationsFor(method) {
+        return this.operations.get(method);
+    }
+}

package/dist/sourceFiles.d.ts

@@ -0,0 +1,16 @@
+/** Read a bounded snapshot; never follow a file symlink or silently accept a size change. */
+export declare function readLocalFile(absolutePath: string, size: number, signal?: AbortSignal): Promise<Buffer>;
+/** Project ignore rules, independent of Git's index and each developer's global configuration. */
+export declare class SourceFileSelection {
+    private readonly root;
+    private readonly outputDirectory;
+    private readonly signal?;
+    private readonly scopes;
+    constructor(root: string, outputDirectory: string, signal?: AbortSignal | undefined);
+    static excluded(path: string): boolean;
+    blocked(path: string): boolean;
+    ignored(path: string, directory: boolean, absolutePath?: string): Promise<boolean>;
+    resolveLink(absolutePath: string): Promise<string>;
+    ignoreContents(path: string): Buffer | undefined;
+    private scope;
+}

package/dist/sourceFiles.js

@@ -0,0 +1,114 @@
+import { lstat, open, realpath } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import ignore from 'ignore';
+/** Read a bounded snapshot; never follow a file symlink or silently accept a size change. */
+export async function readLocalFile(absolutePath, size, signal) {
+    const file = await open(absolutePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size !== size)
+            throw new Error(`App file changed: ${absolutePath}`);
+        const data = Buffer.alloc(size + 1);
+        let length = 0;
+        while (length < data.length) {
+            signal?.throwIfAborted();
+            const { bytesRead } = await file.read(data, length, data.length - length, null);
+            if (!bytesRead)
+                break;
+            length += bytesRead;
+        }
+        if (length !== size)
+            throw new Error(`App file changed: ${absolutePath}`);
+        return data.subarray(0, length);
+    }
+    finally {
+        await file.close();
+    }
+}
+/** Project ignore rules, independent of Git's index and each developer's global configuration. */
+export class SourceFileSelection {
+    root;
+    outputDirectory;
+    signal;
+    scopes = new Map();
+    constructor(root, outputDirectory, signal) {
+        this.root = root;
+        this.outputDirectory = outputDirectory;
+        this.signal = signal;
+    }
+    static excluded(path) {
+        return (path
+            .split('/')
+            .some((part) => /^(?:\.git|node_modules|\.aws|\.ssh|\.sst|\.cache|\.next|\.turbo|coverage|\.DS_Store)$/i.test(part) ||
+            /^(?:\.npmrc|\.netrc|CLAUDE\.local\.md)$/i.test(part) ||
+            (/^\.env(?:\..*)?$/i.test(part) && !/\.(?:example|sample|template)$/i.test(part)) ||
+            /\.(?:pem|key|p12|pfx)$/i.test(part)) ||
+            /(?:^|\/)\.claude\/(?:settings\.local\.json|worktrees|projects)(?:\/|$)/i.test(path) ||
+            /(?:^|\/)\.codex\/(?:auth\.json|history\.jsonl|session_index\.jsonl|sessions|logs)(?:\/|$)/i.test(path) ||
+            /(?:^|\/)\.gemini\/(?:oauth_creds\.json|google_accounts\.json|tmp)(?:\/|$)/i.test(path));
+    }
+    blocked(path) {
+        const output = this.outputDirectory.toLowerCase();
+        return (SourceFileSelection.excluded(path) || path.toLowerCase() === output || path.toLowerCase().startsWith(`${output}/`));
+    }
+    async ignored(path, directory, absolutePath = join(this.root, path)) {
+        const physical = relative(this.root, absolutePath).split(sep).join('/');
+        if (physical !== path && (this.blocked(physical) || (await this.ignored(physical, directory))))
+            return true;
+        // Retain visited ignore files so checkout inherits the same project selection rules.
+        const parts = path.split('/');
+        const scopes = [];
+        for (let depth = 0; depth < parts.length; depth++) {
+            const prefix = parts.slice(0, depth).join('/');
+            scopes.push({ prefix, rules: (await this.scope(prefix)).rules });
+            if (depth === parts.length - 1 && parts[depth] === '.gitignore')
+                return false;
+            const candidate = parts.slice(0, depth + 1).join('/');
+            const suffix = depth < parts.length - 1 || directory ? '/' : '';
+            let ignored = false;
+            for (const scope of scopes) {
+                const result = scope.rules.test(candidate.slice(scope.prefix ? scope.prefix.length + 1 : 0) + suffix);
+                if (result.ignored || result.unignored)
+                    ignored = result.ignored;
+            }
+            if (ignored)
+                return true; // A child rule cannot reinclude a pruned parent directory.
+        }
+        return false;
+    }
+    async resolveLink(absolutePath) {
+        const target = await realpath(absolutePath);
+        const path = relative(this.root, target).split(sep).join('/');
+        if (!path || path === '..' || path.startsWith('../') || path.startsWith('/') || /^[A-Za-z]:/.test(path)) {
+            throw new Error('Source symlinks must target files or directories inside the project.');
+        }
+        if (this.blocked(path) || (await this.ignored(path, (await lstat(target)).isDirectory()))) {
+            throw new Error(`Source symlink target is excluded: ${path}`);
+        }
+        return target;
+    }
+    ignoreContents(path) {
+        const parts = path.split('/');
+        if (parts.pop() !== '.gitignore')
+            return undefined;
+        return this.scopes.get(parts.join('/'))?.contents;
+    }
+    async scope(prefix) {
+        const existing = this.scopes.get(prefix);
+        if (existing)
+            return existing;
+        const path = join(this.root, prefix, '.gitignore');
+        const stat = await lstat(path).catch((error) => {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        });
+        if (stat && (!stat.isFile() || stat.size > 4 * 1024 * 1024))
+            throw new Error('Invalid .gitignore file.');
+        const contents = stat ? await readLocalFile(path, stat.size, this.signal) : undefined;
+        const value = { rules: ignore({ ignorecase: false }).add(contents?.toString('utf8') ?? ''), contents };
+        this.scopes.set(prefix, value);
+        return value;
+    }
+}

package/dist/types.d.ts

@@ -1,5 +1,12 @@
 import type { components } from './generated/openapi.js';
 type PublicApiSchema<Name extends keyof components['schemas']> = components['schemas'][Name];
+export type AppUser = PublicApiSchema<'AppUser'>;
+export type AppGrants = PublicApiSchema<'AppGrants'>;
+export type AppAccess = PublicApiSchema<'AppAccess'>;
+export type AppAddressSettings = PublicApiSchema<'AppAddressSettings'>;
+export type AppAddressSetRequest = PublicApiSchema<'AppAddressSetRequest'>;
+export type AppAccessSetRequest = PublicApiSchema<'AppAccessSetRequest'>;
+export type AppGrantSetRequest = PublicApiSchema<'AppGrantSetRequest'>;
 export type BusinessAction = PublicApiSchema<'BusinessAction'>;
 export type BusinessActionList = PublicApiSchema<'BusinessActionList'>;
 export type ActionCreateRequest = PublicApiSchema<'ActionCreateRequest'>;
@@ -41,6 +48,12 @@ export type FileDatasetCreateRequest = Omit<Extract<DatasetApiCreateRequest, {
     sizeBytes?: number;
     headers?: Record<string, string>;
 };
+export type FileDatasetMetadataCreateRequest = Extract<DatasetApiCreateRequest, {
+    type: 'file';
+}> & {
+    data?: undefined;
+    headers?: undefined;
+};
 export type DatasetCreateRequest = CustomDatasetCreateRequest | FileDatasetCreateRequest;
 export type DatasetWriteTablesRequest = PublicApiSchema<'DatasetWriteTablesRequest'>;
 export type DatasetWriteTablesResponse = PublicApiSchema<'DatasetWriteTablesResponse'>;
@@ -106,6 +119,9 @@ export type AppDeleted = PublicApiSchema<'AppDeleted'>;
 export type AppUploadsRequest = PublicApiSchema<'AppUploadsRequest'>;
 export type AppUploads = PublicApiSchema<'AppUploads'>;
 export type AppSiteSaveRequest = PublicApiSchema<'AppSiteSaveRequest'>;
+export type AppSource = AppSiteSaveRequest['source'];
+export type AppSourceFileQuery = PublicApiSchema<'AppSourceFileQuery'>;
+export type AppSourceFileContent = PublicApiSchema<'AppSourceFileContent'>;
 export type AppUploadFile = {
     path: string;
     data: string | Blob | Uint8Array;
@@ -134,4 +150,7 @@ export type WriteSyncRun = PublicApiSchema<'WriteSyncRun'>;
 export type WriteSyncRunList = PublicApiSchema<'WriteSyncRunList'>;
 export type WriteSyncRunQuery = PublicApiSchema<'WriteSyncRunQuery'>;
 export type WriteSyncExecution = PublicApiSchema<'WriteSyncExecution'>;
+export type ChatSendRequest = PublicApiSchema<'ChatSendRequest'>;
+export type ChatDecisionRequest = PublicApiSchema<'ChatDecisionRequest'>;
+export type ChatResponse = PublicApiSchema<'ChatResponse'>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@permute/sdk",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "TypeScript client for the Permute public API",
   "type": "module",
   "license": "Apache-2.0",
@@ -54,7 +54,8 @@
     "typecheck": "bun run scripts/typecheck.ts"
   },
   "dependencies": {
-    "ajv": "^8.20.0"
+    "ajv": "^8.20.0",
+    "ignore": "7.0.5"
   },
   "devDependencies": {
     "@types/bun": "1.3.13",