@frontera-sdk/cli 1.52.44 → 1.52.46

package/src/pack.ts

@@ -2,6 +2,7 @@ import { collectSourceFiles, formatBytes, type SourceFile } from './packaging'
 import { createTarGz } from './tar'
 import type { Output } from './output'
 import { tsconfigAsKept } from './local/local-app-sdk-paths'
+import { functionSourceFiles, IGNORE_FILE, sourceSizeWarning } from './function-source'
 
 /**
  * Package a directory for upload, reporting its size.
@@ -21,3 +22,18 @@ export function packDirectory(dir: string, output: Output, label: string, extra:
   output.note(`  ${label} ${files.length} files, ${formatBytes(totalBytes)}`)
   return { tgz: createTarGz(files), fileCount: files.length, totalBytes }
 }
+
+/**
+ * A Function's source (`function-source.ts`): what it reaches, less what
+ * `.fronteraignore` leaves out, with the size line and, past the limits, a
+ * warning naming the largest files.
+ */
+export function packFunctionSource(packageRoot: string, entry: string, output: Output, label: string) {
+  const { files, reachedOnly, ignored } = functionSourceFiles(packageRoot, entry)
+  const totalBytes = files.reduce((n, f) => n + f.bytes.byteLength, 0)
+  const how = [reachedOnly ? 'the files it reaches' : null, ignored ? `${ignored} left out by ${IGNORE_FILE}` : null].filter(Boolean).join('; ')
+  output.note(`  ${label} ${files.length} files, ${formatBytes(totalBytes)}${how ? ` (${how})` : ''}`)
+  const warning = sourceSizeWarning(label.replace(/^source of /, ''), files)
+  if (warning) output.note(`  warning: ${warning}`)
+  return { tgz: createTarGz(files), fileCount: files.length, totalBytes, warning }
+}

package/src/project-context.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 
-import { isTrustedBinding, recordBinding } from './binding-registry'
+import { isTrustedBinding, isTrustedOrganizationBinding, recordBinding } from './binding-registry'
 import { findProjectRoot } from './context'
 import { CliError } from './errors'
 import { writeFileAtomic } from './fs-atomic'
@@ -28,6 +28,13 @@ export const CONTEXT_FILE = 'context.json'
 export interface ProjectContext {
   schemaVersion: 1
   profile: string
+  /**
+   * The organization profile organization-scoped commands use here, beside a
+   * workspace `profile` (X3: `auth use <profile> --org-profile <name>`). Named,
+   * never inferred: two customers can share one host, so an organization key
+   * found by its origin could be another customer's.
+   */
+  organizationProfile?: string
 }
 
 export interface FoundContext {
@@ -36,6 +43,10 @@ export interface FoundContext {
   path: string
   /** The directory that owns it — the binding root. */
   root: string
+  /** The organization profile the binding names for organization-scoped commands, when it names one. */
+  organizationProfile?: string
+  /** This machine bound `organizationProfile` here too. */
+  organizationTrusted?: boolean
   /**
    * Did THIS machine bind this root to this profile?
    *
@@ -65,7 +76,9 @@ export function readContextAt(root: string, env: Env): FoundContext | null {
   if (typeof profile !== 'string' || profile.length === 0) {
     throw corrupt(path, 'it names no profile')
   }
-  return { profile, path, root, trusted: isTrustedBinding(root, profile, env) }
+  const org = (parsed as { organizationProfile?: unknown }).organizationProfile
+  const organization = typeof org === 'string' && org ? { organizationProfile: org, organizationTrusted: isTrustedOrganizationBinding(root, org, env) } : {}
+  return { profile, path, root, trusted: isTrustedBinding(root, profile, env), ...organization }
 }
 
 /**
@@ -136,9 +149,9 @@ export function resolveBindingRoot(
  * is a selection the resolver will refuse — a failure mode nobody would connect
  * to having called only half of the pair.
  */
-export function writeContext(root: string, profile: string, env: Env = process.env): string {
+export function writeContext(root: string, profile: string, env: Env = process.env, organizationProfile?: string): string {
   const path = contextPath(root)
-  const body: ProjectContext = { schemaVersion: 1, profile }
+  const body: ProjectContext = { schemaVersion: 1, profile, ...(organizationProfile ? { organizationProfile } : {}) }
   try {
     writeFileAtomic(path, `${JSON.stringify(body, null, 2)}\n`, 0o600)
   } catch (err) {
@@ -161,7 +174,7 @@ export function writeContext(root: string, profile: string, env: Env = process.e
     }
     throw err
   }
-  recordBinding(root, profile, env)
+  recordBinding(root, profile, env, organizationProfile)
   return path
 }
 

package/src/project.ts

@@ -11,6 +11,8 @@ export interface ProjectConfig {
   slug: string
   displayName: string
   description?: string
+  /** Bootstrap icon for the first deploy, from the platform's set by name (X6); the platform owns it after, as the name. */
+  icon?: string
   /**
    * The version a deploy names as its parent: the last deployment from this
    * folder, else the version the working tree was pulled from.
@@ -57,6 +59,7 @@ export function readProject(dir: string): ProjectConfig {
   let config: {
     displayName?: string
     description?: string
+    icon?: unknown
     connectDomains?: unknown
     resourceDomains?: unknown
     outputDirectory?: string
@@ -87,6 +90,7 @@ export function readProject(dir: string): ProjectConfig {
     slug,
     displayName: config.displayName ?? pkg.frontera?.displayName ?? slug,
     description: config.description ?? pkg.frontera?.description,
+    ...(typeof config.icon === 'string' && config.icon.trim() ? { icon: config.icon.trim() } : {}),
     // A folder never deployed from keeps its lineage: the version it was pulled from is the parent.
     parentVersion: state.parentVersion ?? state.pulledVersion ?? null,
     connectDomains: stringList(config.connectDomains ?? pkg.frontera?.connectDomains, 'connectDomains'),

package/src/remote-guard.ts

@@ -0,0 +1,52 @@
+import { FRONTERA_READ_ONLY_COMMANDS } from './forge/permission-rules'
+import { findSolutionRoot, localRuntimeProfileOf } from './local/local-project'
+
+/**
+ * A command from a local project that would change a remote deployment it
+ * was not told to use (Forge improvement plan X3, T7; P4 2.3: "in the project
+ * folder the CLI defaults to the production profile", and only the local-only
+ * `--as` flag stopped an `action submit` reaching it).
+ *
+ * In a project with its own local runtime, a mutating command whose profile
+ * reaches a deployment other than the local runtime, and was not chosen with
+ * `--profile` on this command, names where it is going and asks first. Where
+ * no one can answer (an agent's shell, CI) it is refused, naming the flag that
+ * says so. Reads, offline commands, `auth`, `kit` and `local` (which choose
+ * their own profiles) are never stopped.
+ */
+
+/** Verbs that only read, beside the exact read-only paths the Forge permission rules list. */
+const READ_VERBS = new Set(['list', 'get', 'status', 'show', 'diff', 'current', 'whoami', 'logs', 'query', 'search', 'versions', 'runs', 'plan', 'validate', 'catalog', 'available', 'installs', 'sources', 'requests', 'deployments', 'checks', 'lineage', 'bindings', 'object-sets', 'agents', 'help'])
+
+/** Nouns that pick their own profile, or touch no deployment. */
+const OWN_PROFILE_NOUNS = new Set(['auth', 'kit', 'local', 'help', 'setup', 'init', 'completion', 'mcp', 'forge'])
+
+export function isReadOnlyCommand(meta: { noun: string; verb?: string }): boolean {
+  const path = `${meta.noun}${meta.verb ? ` ${meta.verb}` : ''}`
+  return FRONTERA_READ_ONLY_COMMANDS.includes(path) || (!!meta.verb && READ_VERBS.has(meta.verb))
+}
+
+const LOOPBACK = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?(\/|$)/i
+
+/**
+ * Where a command is going when the guard should ask, or null when it runs
+ * as it is: the profile and its origin.
+ */
+export function remoteFromLocalProject(input: {
+  meta: { noun: string; verb?: string; offline?: boolean }
+  cwd: string
+  profile: string | null
+  profileSource: string
+  apiUrl: string
+}): { profile: string; apiUrl: string; localProfile: string } | null {
+  if (input.meta.offline || OWN_PROFILE_NOUNS.has(input.meta.noun) || isReadOnlyCommand(input.meta)) return null
+  if (input.profileSource === 'flag' || !input.profile || LOOPBACK.test(input.apiUrl)) return null
+  const localProfile = localRuntimeProfileOf(findSolutionRoot(input.cwd))
+  if (!localProfile || input.profile === localProfile || input.profile.startsWith(`${localProfile}-`)) return null
+  return { profile: input.profile, apiUrl: input.apiUrl, localProfile }
+}
+
+/** The question, or the refusal's message: what runs where. */
+export function remoteWords(label: string, target: { profile: string; apiUrl: string; localProfile: string }): string {
+  return `\`frontera ${label}\` would change ${target.apiUrl} (profile ${target.profile}), not this project's local runtime (${target.localProfile})`
+}