forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/compiler/classifier/signals.ts

@@ -15,6 +15,64 @@ export interface PackageSignals {
   nativeAddonEvidence: string[];
 }
 
+export interface SignalProfile {
+  calls: number;
+  totalMs: number;
+  entrypoints: number;
+  exports: number;
+  textFragments: number;
+  corpusBytes: number;
+  packageCount: number;
+  topPackages: SignalPackageProfile[];
+}
+
+export interface SignalPackageProfile {
+  packageName: string;
+  calls: number;
+  totalMs: number;
+  entrypoints: number;
+  exports: number;
+  textFragments: number;
+  corpusBytes: number;
+}
+
+let activeProfile: SignalProfile | undefined;
+let activePackageProfiles: Map<string, SignalPackageProfile> | undefined;
+
+export function resetSignalProfile(): void {
+  activeProfile = {
+    calls: 0,
+    totalMs: 0,
+    entrypoints: 0,
+    exports: 0,
+    textFragments: 0,
+    corpusBytes: 0,
+    packageCount: 0,
+    topPackages: [],
+  };
+  activePackageProfiles = new Map();
+}
+
+export function getSignalProfile(): SignalProfile | undefined {
+  if (!activeProfile) {
+    return undefined;
+  }
+  const topPackages = [...(activePackageProfiles?.values() ?? [])]
+    .sort((a, b) => b.totalMs - a.totalMs)
+    .slice(0, 10)
+    .map((entry) => ({ ...entry }));
+  return {
+    ...activeProfile,
+    packageCount: activePackageProfiles?.size ?? 0,
+    topPackages,
+  };
+}
+
+export function clearSignalProfile(): void {
+  activeProfile = undefined;
+  activePackageProfiles = undefined;
+}
+
 const NODE_BUILTIN_PATTERNS = [
   /\bnode:/,
   /\brequire\s*\(\s*["'](?:fs|child_process|net|http|https|dns|tls|os|crypto)["']/,
@@ -89,9 +147,12 @@ function collectEnvVars(text: string): string[] {
 }
 
 export function gatherSignals(api: PackageApi): PackageSignals {
+  const started = activeProfile ? performance.now() : 0;
   const texts: string[] = [];
+  let exportCount = 0;
   for (const ep of api.entrypoints) {
     for (const exp of ep.exports) {
+      exportCount += 1;
       texts.push(exp.signature);
       if (exp.overloads) texts.push(...exp.overloads);
       if (exp.declarations) texts.push(...exp.declarations);
@@ -112,7 +173,7 @@ export function gatherSignals(api: PackageApi): PackageSignals {
   const nativeAddonEvidence = collectMatches(corpus, NATIVE_ADDON_PATTERNS);
   const envVars = collectEnvVars(corpus);
 
-  return {
+  const result = {
     usesNodeBuiltins: nodeBuiltins.length > 0,
     nodeBuiltins,
     usesNetwork: networkEvidence.length > 0,
@@ -126,4 +187,33 @@ export function gatherSignals(api: PackageApi): PackageSignals {
     usesNativeAddon: nativeAddonEvidence.length > 0,
     nativeAddonEvidence,
   };
+
+  if (activeProfile) {
+    const durationMs = performance.now() - started;
+    activeProfile.calls += 1;
+    activeProfile.totalMs += durationMs;
+    activeProfile.entrypoints += api.entrypoints.length;
+    activeProfile.exports += exportCount;
+    activeProfile.textFragments += texts.length;
+    activeProfile.corpusBytes += corpus.length;
+
+    const packageProfile = activePackageProfiles?.get(api.name) ?? {
+      packageName: api.name,
+      calls: 0,
+      totalMs: 0,
+      entrypoints: 0,
+      exports: 0,
+      textFragments: 0,
+      corpusBytes: 0,
+    };
+    packageProfile.calls += 1;
+    packageProfile.totalMs += durationMs;
+    packageProfile.entrypoints += api.entrypoints.length;
+    packageProfile.exports += exportCount;
+    packageProfile.textFragments += texts.length;
+    packageProfile.corpusBytes += corpus.length;
+    activePackageProfiles?.set(api.name, packageProfile);
+  }
+
+  return result;
 }

package/src/forge/compiler/client-sdk/build-manifest.ts

@@ -16,11 +16,17 @@ export interface ClientManifest {
     queries: string;
     commands: string;
     liveQueries: string;
+    externalQueries: string;
+    externalCommands: string;
   };
   react: {
     entrypoint: string;
     hooks: string[];
   };
+  vue: {
+    entrypoint: string;
+    composables: string[];
+  };
   excluded: {
     actions: string[];
     workflows: string[];
@@ -41,6 +47,18 @@ export interface ReactManifest {
   clientSafe: true;
 }
 
+export interface VueManifest {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  entrypoint: string;
+  composables: string[];
+  queries: string[];
+  commands: string[];
+  liveQueries: string[];
+  clientSafe: true;
+}
+
 const SERVER_ADAPTER_SUFFIX = ".server.ts";
 
 function collectServerAdapters(classified: ClassifiedPackage[]): string[] {
@@ -101,6 +119,8 @@ export function buildClientManifest(
       queries: "POST /queries/:name",
       commands: "POST /commands/:name",
       liveQueries: "GET /live/:name",
+      externalQueries: "POST /external/:service/queries/:name",
+      externalCommands: "POST /external/:service/commands/:name",
     },
     react: {
       entrypoint: "src/forge/_generated/react.ts",
@@ -113,6 +133,17 @@ export function buildClientManifest(
         "useLiveQuery",
       ],
     },
+    vue: {
+      entrypoint: "src/forge/_generated/vue.ts",
+      composables: [
+        "provideForge",
+        "useForgeClient",
+        "useForgeAuth",
+        "useForgeQuery",
+        "useForgeCommand",
+        "useForgeLiveQuery",
+      ],
+    },
     excluded: {
       actions,
       workflows,
@@ -149,3 +180,31 @@ export function buildReactManifest(clientManifest: ClientManifest): ReactManifes
     clientSafe: true,
   };
 }
+
+export function buildVueManifest(clientManifest: ClientManifest): VueManifest {
+  const composables = [
+    "provideForge",
+    "useForgeClient",
+    "useForgeAuth",
+    "useForgeQuery",
+    "useForgeCommand",
+    "useForgeLiveQuery",
+  ];
+
+  return {
+    schemaVersion: "1.0.0",
+    generatorVersion: GENERATOR_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        clientInputHash: clientManifest.inputHash,
+        composables,
+      }),
+    ),
+    entrypoint: "src/forge/_generated/vue.ts",
+    composables,
+    queries: clientManifest.queries,
+    commands: clientManifest.commands,
+    liveQueries: clientManifest.liveQueries,
+    clientSafe: true,
+  };
+}

package/src/forge/compiler/client-sdk/render-client.ts

@@ -1,10 +1,15 @@
-import type { ClientManifest, ReactManifest } from "./build-manifest.ts";
+import type { ClientManifest, ReactManifest, VueManifest } from "./build-manifest.ts";
 
 export function renderClientTypesTs(): string {
   return `export type ForgeStaticAuth = {
   userId?: string;
   tenantId?: string;
+  organizationId?: string;
+  organizationMembershipId?: string;
   role?: string;
+  roles?: string[];
+  permissions?: string[];
+  claims?: Record<string, unknown>;
   token?: string;
   getToken?: () => string | Promise<string>;
   headers?: Record<string, string>;
@@ -14,7 +19,12 @@ export function renderClientTypesTs(): string {
 export type ForgeResolvedAuth = {
   userId?: string;
   tenantId?: string;
+  organizationId?: string;
+  organizationMembershipId?: string;
   role?: string;
+  roles?: string[];
+  permissions?: string[];
+  claims?: Record<string, unknown>;
   token?: string;
   getToken?: () => string | Promise<string>;
   headers?: Record<string, string>;
@@ -52,6 +62,22 @@ export class ForgeError extends Error {
 export type QueryName = keyof typeof import("./api.ts").api.queries;
 export type CommandName = keyof typeof import("./api.ts").api.commands;
 export type LiveQueryName = keyof typeof import("./api.ts").api.liveQueries;
+export type ExternalCommandName = string;
+export type ExternalQueryName = string;
+export type ExternalRuntimeRefObject = {
+  service: string;
+  name: string;
+  kind?: "command" | "query";
+  language?: string;
+  framework?: string;
+  transport?: string;
+};
+export type ExternalCommandRef =
+  | ExternalCommandName
+  | ExternalRuntimeRefObject;
+export type ExternalQueryRef =
+  | ExternalQueryName
+  | ExternalRuntimeRefObject;
 
 export type LiveSnapshot<T> = {
   subscriptionId: string;
@@ -60,6 +86,22 @@ export type LiveSnapshot<T> = {
   traceId?: string;
 };
 
+export type ForgeCommandResult<T = unknown> =
+  | {
+      ok: true;
+      result: T;
+      status: number;
+      traceId?: string;
+      diagnostics?: { code: string; message: string }[];
+    }
+  | {
+      ok: false;
+      error: { code: string; message: string; details?: unknown };
+      status: number;
+      traceId?: string;
+      diagnostics?: { code: string; message: string }[];
+    };
+
 export type LiveQueryOptions = {
   signal?: AbortSignal;
 };
@@ -70,6 +112,9 @@ export type ForgeClient = {
   readonly lastTraceId?: string;
   query<Name extends QueryName>(name: Name, args: unknown): Promise<unknown>;
   command<Name extends CommandName>(name: Name, args: unknown): Promise<unknown>;
+  commandResult<Name extends CommandName>(name: Name, args: unknown): Promise<ForgeCommandResult<unknown>>;
+  externalQuery<Name extends ExternalQueryRef>(name: Name, args: unknown): Promise<unknown>;
+  externalCommand<Name extends ExternalCommandRef>(name: Name, args: unknown): Promise<unknown>;
   liveQuery<Name extends LiveQueryName>(
     name: Name,
     args: unknown,
@@ -85,8 +130,11 @@ export function renderClientTs(): string {
   return `import { api } from "./api.ts";
 import type {
   ForgeAuthProvider,
+  ForgeCommandResult,
   ForgeClient,
   ForgeClientConfig,
+  ExternalCommandRef,
+  ExternalQueryRef,
   LiveQueryOptions,
   LiveSnapshot,
 } from "./clientTypes.ts";
@@ -98,10 +146,16 @@ export type {
   ForgeAuthProvider,
   ForgeClient,
   ForgeClientConfig,
+  ForgeCommandResult,
   ForgeStaticAuth,
   QueryName,
   CommandName,
   LiveQueryName,
+  ExternalCommandName,
+  ExternalQueryName,
+  ExternalRuntimeRefObject,
+  ExternalCommandRef,
+  ExternalQueryRef,
   ForgeResolvedAuth,
   LiveQueryOptions,
   LiveSnapshot,
@@ -134,7 +188,12 @@ async function resolveAuthHeaders(
       typeof value === "string" &&
       key !== "userId" &&
       key !== "tenantId" &&
+      key !== "organizationId" &&
+      key !== "organizationMembershipId" &&
       key !== "role" &&
+      key !== "roles" &&
+      key !== "permissions" &&
+      key !== "claims" &&
       key !== "token"
     ) {
       headers[key] = value;
@@ -147,9 +206,25 @@ async function resolveAuthHeaders(
   if (resolved.tenantId) {
     headers["x-forge-tenant-id"] = resolved.tenantId;
   }
+  if (resolved.organizationId) {
+    headers["x-forge-organization-id"] = resolved.organizationId;
+    headers["x-forge-tenant-id"] ??= resolved.organizationId;
+  }
+  if (resolved.organizationMembershipId) {
+    headers["x-forge-organization-membership-id"] = resolved.organizationMembershipId;
+  }
   if (resolved.role) {
     headers["x-forge-role"] = resolved.role;
   }
+  if (Array.isArray(resolved.roles)) {
+    headers["x-forge-roles"] = JSON.stringify(resolved.roles);
+  }
+  if (Array.isArray(resolved.permissions)) {
+    headers["x-forge-permissions"] = JSON.stringify(resolved.permissions);
+  }
+  if (resolved.claims && typeof resolved.claims === "object") {
+    headers["x-forge-claims"] = JSON.stringify(resolved.claims);
+  }
 
   return headers;
 }
@@ -179,6 +254,16 @@ function parseJsonPayload(body: unknown): {
   };
 }
 
+function normalizeExternalRef(
+  ref: ExternalCommandRef | ExternalQueryRef,
+): { service: string; name: string } {
+  if (typeof ref === "string") {
+    const [service, ...entryParts] = ref.split(".");
+    return { service: service ?? "", name: entryParts.join(".") };
+  }
+  return { service: ref.service, name: ref.name };
+}
+
 class ForgeHttpClient implements ForgeClient {
   lastTraceId?: string;
 
@@ -192,6 +277,18 @@ class ForgeHttpClient implements ForgeClient {
     return this.invoke("commands", name, args);
   }
 
+  commandResult(name: string, args: unknown): Promise<ForgeCommandResult<unknown>> {
+    return this.invokeResult("commands", name, args);
+  }
+
+  externalQuery(name: ExternalQueryRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("queries", name, args);
+  }
+
+  externalCommand(name: ExternalCommandRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("commands", name, args);
+  }
+
   liveQuery(
     name: string,
     args: unknown,
@@ -223,10 +320,117 @@ class ForgeHttpClient implements ForgeClient {
     name: string,
     args: unknown,
   ): Promise<unknown> {
+    const result = await this.invokeResult(kind, name, args);
+    if (!result.ok) {
+      throw new ForgeError(result.error.message, {
+        code: result.error.code,
+        traceId: result.traceId,
+        status: result.status,
+        details: result.error.details ?? result.diagnostics,
+      });
+    }
+    return result.result;
+  }
+
+  private async invokeResult(
+    kind: "queries" | "commands",
+    name: string,
+    args: unknown,
+  ): Promise<ForgeCommandResult<unknown>> {
     const baseUrl = this.config.url.replace(/\\/$/, "");
     const url = \`\${baseUrl}/\${kind}/\${encodeURIComponent(name)}\`;
     const authHeaders = await resolveAuthHeaders(this.config.auth);
 
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders,
+        },
+        body: JSON.stringify({ args }),
+      });
+    } catch (error) {
+      return {
+        ok: false,
+        status: 0,
+        error: {
+          code: "FORGE_NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "network request failed",
+          details: error,
+        },
+      };
+    }
+
+    let body: unknown;
+    try {
+      body = await response.json();
+    } catch {
+      return {
+        ok: false,
+        status: response.status,
+        error: {
+          code: "FORGE_HTTP_ERROR",
+          message: \`HTTP \${response.status}\`,
+        },
+      };
+    }
+
+    const payload = parseJsonPayload(body);
+    this.lastTraceId = payload.traceId;
+
+    if (!response.ok || payload.ok === false) {
+      const diagnostic = payload.diagnostics?.find((entry) => entry.code);
+      const code =
+        payload.error?.code ?? diagnostic?.code ?? "FORGE_REQUEST_FAILED";
+      const message =
+        payload.error?.message ??
+        diagnostic?.message ??
+        \`Request failed with status \${response.status}\`;
+      return {
+        ok: false,
+        status: response.status,
+        traceId: payload.traceId,
+        diagnostics: payload.diagnostics,
+        error: {
+          code,
+          message,
+          details: payload.error?.details ?? payload.diagnostics,
+        },
+      };
+    }
+
+    return {
+      ok: true,
+      result: payload.result,
+      status: response.status,
+      traceId: payload.traceId,
+      diagnostics: payload.diagnostics,
+    };
+  }
+
+  private async invokeExternal(
+    kind: "queries" | "commands",
+    name: ExternalCommandRef | ExternalQueryRef,
+    args: unknown,
+  ): Promise<unknown> {
+    const normalized = normalizeExternalRef(name);
+    const serviceName = normalized.service;
+    const entryName = normalized.name;
+    if (!serviceName || !entryName) {
+      throw new ForgeError(\`External runtime name must be service.entry\`, {
+        code: "FORGE_EXTERNAL_RUNTIME_NOT_FOUND",
+      });
+    }
+    const baseUrl = this.config.url.replace(/\\/$/, "");
+    const url = \`\${baseUrl}/external/\${encodeURIComponent(serviceName)}/\${kind}/\${encodeURIComponent(entryName)}\`;
+    return this.invokeUrl(url, args);
+  }
+
+  private async invokeUrl(url: string, args: unknown): Promise<unknown> {
+    const authHeaders = await resolveAuthHeaders(this.config.auth);
+
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -297,19 +501,24 @@ class ForgeHttpClient implements ForgeClient {
     const reader = response.body.getReader();
     let buffer = "";
 
-    while (!signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf("\\n\\n");
-      while (boundary !== -1) {
-        const frame = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        this.handleSseFrame(frame, onSnapshot, onError);
-        boundary = buffer.indexOf("\\n\\n");
+    try {
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf("\\n\\n");
+        while (boundary !== -1) {
+          const frame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          this.handleSseFrame(frame, onSnapshot, onError);
+          boundary = buffer.indexOf("\\n\\n");
+        }
       }
+    } finally {
+      await reader.cancel().catch(() => undefined);
+      reader.releaseLock();
     }
   }
 
@@ -383,8 +592,11 @@ export type {
   ForgeReactAuthProvider,
   ForgeReactClient,
   ForgeReactError,
+  ForgeCommandCallResult,
   UseCommandOptions,
   UseCommandResult,
+  UseCommandResultHook,
+  UseCommandResultOptions,
   UseLiveQueryOptions,
   UseLiveQueryResult,
   UseQueryOptions,
@@ -398,6 +610,7 @@ export const useForgeClient = forgeReact.useForgeClient;
 export const useAuth = forgeReact.useAuth;
 export const useQuery = forgeReact.useQuery;
 export const useCommand = forgeReact.useCommand;
+export const useCommandResult = forgeReact.useCommandResult;
 export const useLiveQuery = forgeReact.useLiveQuery;
 `;
 }
@@ -410,8 +623,11 @@ export function renderReactDts(): string {
   ForgeReactAuthProvider,
   ForgeReactClient,
   ForgeReactError,
+  ForgeCommandCallResult,
   UseCommandOptions,
   UseCommandResult,
+  UseCommandResultHook,
+  UseCommandResultOptions,
   UseLiveQueryOptions,
   UseLiveQueryResult,
   UseQueryOptions,
@@ -423,6 +639,7 @@ export declare const useForgeClient: import("forge/react").ForgeReactBindings["u
 export declare const useAuth: import("forge/react").ForgeReactBindings["useAuth"];
 export declare const useQuery: import("forge/react").ForgeReactBindings["useQuery"];
 export declare const useCommand: import("forge/react").ForgeReactBindings["useCommand"];
+export declare const useCommandResult: import("forge/react").ForgeReactBindings["useCommandResult"];
 export declare const useLiveQuery: import("forge/react").ForgeReactBindings["useLiveQuery"];
 `;
 }
@@ -430,3 +647,68 @@ export declare const useLiveQuery: import("forge/react").ForgeReactBindings["use
 export function renderReactManifestTs(manifest: ReactManifest): string {
   return `export const reactManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
 }
+
+export function renderVueTs(): string {
+  return `import { createForgeVueBindings } from "forge/vue";
+import { createForgeClient } from "./client.ts";
+
+export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+const forgeVue = createForgeVueBindings(createForgeClient);
+
+export const ForgeVuePlugin = forgeVue.ForgeVuePlugin;
+export const provideForge = forgeVue.provideForge;
+export const useForgeClient = forgeVue.useForgeClient;
+export const useForgeAuth = forgeVue.useForgeAuth;
+export const useForgeQuery = forgeVue.useForgeQuery;
+export const useForgeCommand = forgeVue.useForgeCommand;
+export const useForgeLiveQuery = forgeVue.useForgeLiveQuery;
+`;
+}
+
+export function renderVueDts(): string {
+  return `export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+export declare const ForgeVuePlugin: import("forge/vue").ForgeVueBindings["ForgeVuePlugin"];
+export declare const provideForge: import("forge/vue").ForgeVueBindings["provideForge"];
+export declare const useForgeClient: import("forge/vue").ForgeVueBindings["useForgeClient"];
+export declare const useForgeAuth: import("forge/vue").ForgeVueBindings["useForgeAuth"];
+export declare const useForgeQuery: import("forge/vue").ForgeVueBindings["useForgeQuery"];
+export declare const useForgeCommand: import("forge/vue").ForgeVueBindings["useForgeCommand"];
+export declare const useForgeLiveQuery: import("forge/vue").ForgeVueBindings["useForgeLiveQuery"];
+`;
+}
+
+export function renderVueManifestTs(manifest: VueManifest): string {
+  return `export const vueManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
+}