stablyai/orca · error · RuntimeClientError

artifact_sharing_disabled

artifact_sharing_disabled

Error message

Publishing artifacts is off for this device. Nothing running here — agents or the orca CLI — can mint public artifact links until you allow it.

What it means

Thrown by preflightPublishCapability() when settings.get returns artifactSharingEnabled === false. The preflight is deliberately conservative: a thrown settings RPC is swallowed (returns silently), and only an explicit boolean false denies — older hosts that omit the field and unreachable hosts pass through so the publish RPC itself reports those. This is the common outcome because sharing is off by default; the error includes nextSteps guidance.

Source

Thrown at src/cli/handlers/artifacts.ts:101

/**
 * Publishing is off by default, so denial is the common outcome. A tiny `settings.get` read
 * answers it before we load (or pipe in) up to the full RPC byte budget the host would reject.
 * Only an explicit `false` denies: a host predating the capability omits the field entirely,
 * and an unreachable host stays the publish RPC's problem, not the preflight's.
 */
async function preflightPublishCapability(ctx: HandlerContext): Promise<void> {
  let enabled: unknown
  try {
    const response = await ctx.client.call<{
      settings?: { artifactSharingEnabled?: boolean }
    }>('settings.get')
    enabled = response.result?.settings?.artifactSharingEnabled
  } catch {
    return
  }
  if (enabled === false) {
    throw new RuntimeClientError(
      ARTIFACT_SHARING_DISABLED_CODE,
      ARTIFACT_SHARING_DISABLED_MESSAGE,
      { nextSteps: [...ARTIFACT_SHARING_DISABLED_NEXT_STEPS] }
    )
  }
}

async function readArtifactRequest(ctx: HandlerContext): Promise<ArtifactWriteRequest> {
  const remoteInput = parseRemoteArtifactInput(process.env[REMOTE_ARTIFACT_INPUT_ENV])
  const sourceKey = remoteInput?.sourceKey ?? resolve(ctx.cwd, requireStringFlag(ctx, 'file'))
  const contentType = remoteInput?.contentType ?? artifactContentType(sourceKey)
  if (!contentType) {
    throw new RuntimeClientError('invalid_argument', 'Artifacts must be HTML or Markdown files.')
  }
  await preflightPublishCapability(ctx)
  const localRead = remoteInput
    ? null
    : await readArtifactFileWithinLimit(sourceKey, ARTIFACT_CLI_MAX_RPC_BYTES)

View on GitHub (pinned to 1136503c6a)

Solutions

Enable artifact sharing in Orca settings (set artifactSharingEnabled to true) for this device, then retry.
If an admin controls the setting, request they enable it for your account/device.
Follow the nextSteps attached to the error (ARTIFACT_SHARING_DISABLED_NEXT_STEPS) for the exact UI path.
If the setting is correct but the error persists, confirm the desktop client is running the current version (older hosts omit the field and should NOT trigger this — investigate the settings.get response).

Example fix

// before: settings.artifactSharingEnabled === false
orca artifacts share --file r.html   // ERROR artifact_sharing_disabled

// after: enable in Orca settings, then
orca artifacts share --file r.html

Defensive patterns

Strategy: try-catch

Validate before calling

async function canShareArtifacts(client: HandlerContext['client']): Promise<boolean> {
  try {
    const r = await client.call<{settings?:{artifactSharingEnabled?:boolean}}>('settings.get')
    return r.result?.settings?.artifactSharingEnabled !== false
  } catch {
    return true // unreachable/older host: let the publish RPC decide
  }
}

Type guard

const sharingExplicitlyDisabled = (resp: unknown): boolean =>
  typeof resp === 'object' && resp !== null &&
  (resp as any).result?.settings?.artifactSharingEnabled === false

Try / catch

try {
  await dispatch('artifacts share', ctx)
} catch (e) {
  if (e instanceof RuntimeClientError && e.code === 'artifact_sharing_disabled') {
    // prompt user to enable artifactSharingEnabled, follow e.nextSteps, then retry
  }
  throw e
}

Prevention

Cache the settings.get result per session to avoid repeated preflight round-trips.
Remember only explicit false denies; missing field means allowed (older host).
Surface nextSteps from the error to the user verbatim.

When it happens

Trigger: Running `artifacts share` or `artifacts update` on a device where artifact sharing has been explicitly disabled in settings (artifactSharingEnabled: false). Fires after content-type validation but before the file is read, to avoid loading up to the full RPC budget only to be denied.

Common situations: Fresh device/team where an admin locked down sharing; a policy push that flipped the setting to false; local dev where the user toggled it off and forgot; a shared machine where another user disabled it.

Related errors

AI-assisted analysis of stablyai/orca@1136503c6a (2026-08-12). Data as JSON: /api/errors/75a593b08894ef7b. Report an issue: GitHub.