Configure ClineCore for Privacy-Aware Coding Sessions

Configure the session before sending private code

ClineCore gives an application a way to create a runtime and start sessions with model and runtime configuration. The practical privacy decision is not just which provider to use: it is also what data the session receives, which tools can act on it, and what your application persists or exposes afterward.

The examples below are illustrative, not tested integrations. The ClineCore reference documents the API shape, but does not establish that every provider accepts the same model parameters or endpoint settings. Check your provider’s documentation before relying on provider-specific options.

Separate shared settings from session settings

The ClineCore.create options cover choices such as the client name, backend mode, tool policies, capabilities, and whether automation is enabled. The start call requires a config with session model/runtime settings. The documented example includes providerId, modelId, apiKey, systemPrompt, cwd, workspaceRoot, and tool and agent flags.

A minimal server-side pattern looks like this:

import { ClineCore } from "@cline/sdk"

const cline = await ClineCore.create({
  clientName: "private-code-review",
  backendMode: "auto",
  toolPolicies: {
    // Set policies for the tools your application exposes.
  },
})

const session = await cline.start({
  prompt: "Review the selected files for risky input handling.",
  config: {
    providerId: process.env.CLINE_PROVIDER_ID!,
    modelId: process.env.CLINE_MODEL_ID!,
    apiKey: process.env.CLINE_API_KEY!,
    systemPrompt: "Review only the supplied code. Do not request secrets.",
    cwd: process.cwd(),
    workspaceRoot: process.cwd(),
    enableTools: false,
    enableSpawnAgent: false,
    enableAgentTeams: false,
  },
})

This example uses environment variables as a credential-handling practice; the reference does not prescribe a secrets manager or define these environment variable names. Keep the key on a trusted server, do not send it to browser code, and avoid printing session configuration to application logs. If the provider requires an endpoint or additional parameters, configure them only as its documentation directs and verify that ClineCore supports the required fields.

Make privacy decisions explicit

Before starting a session, decide what the agent needs. Prefer a narrow workspace or selected files over an entire repository when the task allows it. Exclude secrets, personal data, and unrelated files from the material supplied to the agent. A system prompt can state handling expectations, but it is not a substitute for access controls or data minimization.

Review tool access as carefully as prompt content. ClineCore accepts default and per-session tool policies, and runtime capabilities can include client-owned tool executors and approval callbacks. Keep tools disabled when the task does not require them; where tools are needed, use policies and approvals appropriate to their effects. The reference documents these configuration hooks, but does not define the behavior of each tool or guarantee that a particular policy prevents every sensitive action.

Treat session records as potentially sensitive. The API can list sessions, retrieve metadata and messages, read accumulated usage, update records, and delete sessions. Those capabilities mean your application should decide who can call these methods and what retention rules apply. Avoid putting secrets or unnecessary personal information in sessionMetadata, initial messages, or prompts: metadata and messages are session data, not secure secret storage.

The distinctId option is described as a stable telemetry/user identifier. If you use it, consider whether a stable identifier is necessary for your application and whether it could identify a person. The reference does not explain telemetry collection, retention, or anonymization, so do not assume that the identifier is anonymous or that setting it controls all telemetry.

Troubleshoot common setup failures

• Session creation rejects the configuration: Confirm that config is present and that the provider and model identifiers match the provider’s accepted values. The supplied reference gives an example, not a complete provider catalogue.
• Authentication fails: Check that the key is available in the server process, corresponds to the selected provider, and has not been accidentally trimmed or replaced. Never include the key in a diagnostic prompt or paste it into a ticket.
• A provider-specific option is ignored or rejected: The ClineCore reference does not document universal endpoint or parameter compatibility. Check the provider and SDK documentation rather than assuming one provider’s settings transfer to another.
• A session can perform more actions than intended: Review enableTools, tool policies, and supplied capabilities. Start with tools disabled when they are unnecessary, then enable only what the workflow needs.
• Sensitive content appears in history: Review which application paths call readMessages, list, and related session APIs, then apply appropriate authorization and retention controls. The reference exposes these APIs but does not specify your application’s storage or access protections.
• Work continues unexpectedly: Use the documented abort or stop method for the session, and dispose of runtime resources when the application is finished with them.

A reusable preflight checklist

Before enabling a ClineCore workflow, confirm that the credential stays server-side; the workspace contains only needed files; prompts and metadata contain no secrets; tool access is limited and reviewed; session history has an owner and retention policy; and provider-specific settings have been checked against current provider documentation. For debugging, log non-sensitive facts such as whether a session started and which internal request ID applies—not credentials, full prompts, or source files.

The ClineCore reference supports configuration and session-management hooks, not a blanket privacy guarantee. Privacy-aware operation depends on how your application supplies data, gates tools, protects session records, and handles credentials.

Source

• ClineCore API reference — API options, session configuration, session-management methods, and automation overview.