runline 0.1.0

package/.pi/extensions/runline-context/index.ts

@@ -0,0 +1,135 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Markdown, Text } from "@mariozechner/pi-tui";
+import { Runline } from "../../../src/sdk.js";
+
+function formatActions(
+  actions: Array<{
+    plugin: string;
+    action: string;
+    description?: string;
+    inputSchema?: Record<string, { type: string; required?: boolean; description?: string }>;
+  }>,
+): string {
+  const grouped = new Map<string, typeof actions>();
+  for (const a of actions) {
+    const list = grouped.get(a.plugin) ?? [];
+    list.push(a);
+    grouped.set(a.plugin, list);
+  }
+
+  const lines: string[] = [];
+  for (const [plugin, entries] of grouped) {
+    lines.push(`### ${plugin}`);
+    for (const a of entries) {
+      const inputs = a.inputSchema
+        ? Object.entries(a.inputSchema)
+            .map(
+              ([k, v]) =>
+                `${k}: ${v.type}${v.required ? "" : "?"}`,
+            )
+            .join(", ")
+        : "";
+      const sig = inputs
+        ? `\`${plugin}.${a.action}({ ${inputs} })\``
+        : `\`${plugin}.${a.action}()\``;
+      const desc = a.description ? ` — ${a.description}` : "";
+      lines.push(`- ${sig}${desc}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerMessageRenderer(
+    "runline-context",
+    (message, { expanded }, theme) => {
+      if (!expanded) {
+        const label = theme.fg("customMessageLabel", "⚡ runline actions");
+        const hint = theme.fg("dim", " — Ctrl+O to expand");
+        return new Text(label + hint, 1, 0);
+      }
+      return new Markdown(
+        message.content,
+        1,
+        0,
+        {
+          heading: (t) => theme.fg("mdHeading", t),
+          link: (t) => theme.fg("mdLink", t),
+          linkUrl: (t) => theme.fg("mdLinkUrl", t),
+          code: (t) => theme.fg("mdCode", t),
+          codeBlock: (t) => theme.fg("mdCodeBlock", t),
+          codeBlockBorder: (t) => theme.fg("mdCodeBlockBorder", t),
+          quote: (t) => theme.fg("mdQuote", t),
+          quoteBorder: (t) => theme.fg("mdQuoteBorder", t),
+          hr: (t) => theme.fg("mdHr", t),
+          listBullet: (t) => theme.fg("mdListBullet", t),
+          bold: (t) => theme.bold(t),
+          italic: (t) => theme.italic(t),
+          strikethrough: (t) => theme.strikethrough(t),
+          underline: (t) => theme.underline(t),
+        },
+        { color: (t) => theme.fg("customMessageText", t) },
+      );
+    },
+  );
+
+  pi.on("session_start", async (_event, ctx) => {
+    const rl = await Runline.fromProject(ctx.cwd);
+
+    if (!rl) {
+      if (ctx.hasUI) {
+        ctx.ui.setStatus("runline", ctx.ui.theme.fg("dim", "runline: no .runline/"));
+      }
+      return;
+    }
+
+    const actions = rl.actions();
+    const plugins = rl.plugins();
+
+    if (actions.length === 0) {
+      if (ctx.hasUI) {
+        ctx.ui.setStatus("runline", ctx.ui.theme.fg("dim", "runline: no plugins"));
+      }
+      return;
+    }
+
+    // Check if already injected
+    const alreadyInjected = ctx.sessionManager
+      .getEntries()
+      .some(
+        (e: any) =>
+          e.type === "message" &&
+          e.message.role === "custom" &&
+          e.message.customType === "runline-context",
+      );
+
+    if (!alreadyInjected) {
+      const header =
+        "## Runline actions\n\n" +
+        "This project has runline installed. You can execute JavaScript in a sandbox " +
+        "where each installed plugin is a top-level global. Chain actions together, " +
+        "call `help()` or `pluginName.help()` inside the sandbox for discovery.\n\n" +
+        `**${plugins.length} plugins, ${actions.length} actions available.**\n\n` +
+        "Use `runline exec '<code>'` to run code. Examples:\n" +
+        "```js\n" +
+        "return await github.issue.create({ owner: \"acme\", repo: \"api\", title: \"Bug\" })\n" +
+        "```\n\n";
+
+      ctx.sessionManager.appendCustomMessageEntry(
+        "runline-context",
+        header + formatActions(actions),
+        true,
+      );
+    }
+
+    if (ctx.hasUI) {
+      const theme = ctx.ui.theme;
+      ctx.ui.setStatus(
+        "runline",
+        `⚡${theme.fg("dim", ` runline: ${plugins.length} plugins, ${actions.length} actions`)}`,
+      );
+    }
+  });
+}

package/.pi/extensions/runline-context/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@miclivs/pi-runline-context",
+  "version": "0.1.0",
+  "description": "Pi extension — injects runline actions into agent context",
+  "type": "commonjs",
+  "keywords": ["pi-package"],
+  "files": ["index.ts", "README.md"],
+  "pi": {
+    "extensions": ["."]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  },
+  "author": "michaelliv",
+  "license": "MIT"
+}

package/README.md

@@ -0,0 +1,273 @@
+# runline ⚡
+
+Code mode for agents.
+
+Turn any API into a callable action. Install a plugin, write JavaScript, call actions. The code runs in a QuickJS WASM sandbox — no filesystem, no network, just plugin actions via a proxy.
+
+```bash
+npm install -g runline
+```
+
+## Quick Start
+
+```bash
+runline init
+runline plugin install git:github.com/Michaelliv/runline#plugins/brandfetch
+runline connection add bf --plugin brandfetch --set apiKey=xxx
+
+runline exec 'return await brandfetch.brand.getColors({ domain: "nike.com" })'
+# => [{ hex: "#E5E5E5", type: "accent" }, { hex: "#111111", type: "dark" }, ...]
+```
+
+Agent code runs in a QuickJS sandbox. Each installed plugin is a top-level global — no bracket notation, just dot-chain into resource and action. Plugins execute outside the sandbox with full network access; the agent can only reach APIs through the actions you've installed.
+
+```js
+// agent writes this
+const company = await brandfetch.brand.getCompany({ domain: "stripe.com" });
+const deals = await pipedrive.deal.list({ limit: 10 });
+const issue = await github.issue.create({
+  owner: "acme", repo: "api",
+  title: `New lead: ${company.name}`,
+  body: `${deals.length} open deals`
+});
+return { company: company.name, issue: issue.number };
+```
+
+## Plugins
+
+188 plugins covering popular SaaS, DevOps, and productivity APIs. Each wraps a single service's REST/GraphQL API with typed actions.
+
+All plugins install via `runline plugin install git:github.com/Michaelliv/runline#plugins/<name>`.
+
+| Plugin | Actions | Auth |
+|--------|---------|------|
+| **github** | file/issue/pr/release/repo/review/user CRUD, search | Bearer token |
+| **gitlab** | issue/merge request/repo/user CRUD | Bearer token |
+| **jira** | issue/project/user CRUD, transitions | Basic auth |
+| **slack** | channel/message/user/reaction/star/file ops | Bearer token |
+| **discord** | channel/message/member CRUD, reactions | Bot token |
+| **notion** | block/database/page/user CRUD, search | Bearer token |
+| **todoist** | task/project/section/comment/label CRUD | Bearer token |
+| **linear** | issue/project/team/comment CRUD (GraphQL) | Bearer token |
+| **hubspot** | contact/company/deal/ticket/engagement CRUD | Bearer token |
+| **pipedrive** | deal/person/org/activity/lead/note/product CRUD, search | API token |
+| **salesforce** | account/contact/lead/opportunity/case/task CRUD | OAuth2 |
+| **shopify** | order/product/customer CRUD | API key |
+| **stripe** | charge/customer/source/coupon CRUD | Bearer token |
+| **airtable** | base/record CRUD, search, upsert | Bearer token |
+| **supabase** | row CRUD | API key |
+| **docker** | container/image/volume/network ops | Unix socket |
+| **telegram** | message/chat/callback/pin ops | Bot token in URL |
+| **twitter** | tweet/user/dm/list ops | OAuth2 Bearer |
+| **clickup** | task/list/folder/space/comment/checklist/team CRUD | Bearer token |
+| **asana** | task/project/section/subtask/tag/user CRUD | Bearer token |
+| **trello** | board/list/card/checklist/attachment/label/member CRUD | API key |
+| **monday** | board/group/item/column/update (GraphQL) | Bearer token |
+| **mailchimp** | list/member/campaign/tag ops | Bearer token |
+| **sendgrid** | contact/list/email ops | Bearer token |
+| **elasticsearch** | document/index CRUD | Basic auth |
+| **cloudflare** | zone/dns/worker/kv/r2/d1/pages/queue CRUD | Bearer token |
+| **databricks** | sql/files/genie/catalog/table/volume/function/vector search | Bearer token |
+| **splunk** | search/alert/report/user CRUD | Bearer token |
+| **home-assistant** | state/service/history/config/template/event ops | Bearer token |
+| **openweathermap** | current/5-day forecast | API key |
+| **brandfetch** | logos/colors/fonts/company/industry lookup | Bearer token |
+
+<details>
+<summary>All 188 plugins</summary>
+
+actionNetwork, activeCampaign, adalo, affinity, agileCrm, airtable, airtop, apiTemplateIo, asana, autopilot, bambooHr, bannerbear, baserow, beeminder, bitly, bitwarden, box, brandfetch, brevo, bubble, chargebee, circleci, ciscoWebex, clearbit, clickup, clockify, cloudflare, cockpit, coda, coingecko, contentful, convertkit, copper, cortex, currents, customerIo, databricks, deepl, demio, dhl, discord, discourse, disqus, docker, drift, dropbox, dropcontact, egoi, elasticsearch, emelia, erpnext, facebookGraph, freshdesk, freshservice, freshworksCrm, getresponse, ghost, github, gitlab, gong, gotify, gotowebinar, grafana, graphql, grist, hackernews, halopsa, harvest, helpscout, highlevel, homeAssistant, hubspot, humanticAi, hunter, intercom, iterable, jenkins, jira, keap, kobotoolbox, lemlist, line, linear, lingvanex, linkedin, lonescale, magento, mailcheck, mailchimp, mailerlite, mailgun, mailjet, mandrill, marketstack, matrix, mattermost, mautic, medium, messagebird, metabase, misp, mocean, monday, monicaCrm, msg91, nasa, netlify, netscalerAdc, nextcloud, nocodb, notion, npm, odoo, okta, oneSimpleApi, onfleet, openThesaurus, openweathermap, oura, paddle, pagerduty, paypal, peekalink, phantombuster, philipsHue, pipedrive, plivo, postbin, posthog, profitwell, pushbullet, pushcut, pushover, quickbase, quickbooks, quickchart, raindrop, reddit, rocketchat, rundeck, salesforce, salesmate, securityScorecard, segment, sendgrid, sendy, sentry, servicenow, shopify, signl4, slack, sms77, splunk, spotify, stackby, storyblok, strapi, strava, stripe, supabase, syncromsp, tapfiliate, telegram, thehive, thehiveProject, todoist, travisci, trello, twake, twilio, twist, twitter, unleashedSoftware, uplead, uproc, uptimerobot, urlscanio, vero, vonage, wekan, woocommerce, wordpress, xero, yourls, zammad, zendesk, zoho, zoom, zulip
+
+</details>
+
+## Examples
+
+```bash
+# List all available actions
+runline actions
+
+# Get Nike's brand colors
+runline exec 'return await brandfetch.brand.getColors({ domain: "nike.com" })'
+
+# Create a GitHub issue
+runline exec '
+  return await github.issue.create({
+    owner: "acme", repo: "api",
+    title: "Bug: login broken",
+    labels: ["bug", "urgent"]
+  })
+'
+
+# Search Pipedrive deals
+runline exec 'return await pipedrive.deal.search({ term: "Acme" })'
+
+# Chain actions together
+runline exec '
+  const contact = await hubspot.contact.get({ id: "123" });
+  const task = await todoist.task.create({
+    content: `Follow up with ${contact.properties.firstname}`,
+    priority: 4
+  });
+  return { contact: contact.properties.email, taskId: task.id };
+'
+
+# Discover actions from inside the sandbox
+runline exec 'return brandfetch.help()'
+runline exec 'return help()'
+
+# Output as JSON (for agents)
+runline exec 'return await github.repo.list({ owner: "torvalds" })' --json
+```
+
+## Writing a Plugin
+
+Plugins export a function that receives a `RunlinePluginAPI` and registers actions.
+
+```typescript
+import type { RunlinePluginAPI } from "runline";
+
+export default function orders(rl: RunlinePluginAPI) {
+  rl.setName("orders");
+  rl.setVersion("1.0.0");
+
+  // Connection config — env vars override config.json values
+  rl.setConnectionSchema({
+    apiKey: { type: "string", required: true, env: "ORDERS_API_KEY" },
+    baseUrl: { type: "string", required: true, env: "ORDERS_BASE_URL" },
+  });
+
+  rl.registerAction("list", {
+    description: "List orders for an organization",
+    inputSchema: {
+      orgId: { type: "string", required: true },
+      status: { type: "string", required: false, description: "open, closed, or all" },
+      limit: { type: "number", required: false },
+    },
+    async execute(input, ctx) {
+      const { orgId, status, limit } = input as Record<string, unknown>;
+      const url = new URL(`${ctx.connection.config.baseUrl}/orgs/${orgId}/orders`);
+      if (status) url.searchParams.set("status", status as string);
+      if (limit) url.searchParams.set("limit", String(limit));
+
+      const res = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${ctx.connection.config.apiKey}` },
+      });
+      if (!res.ok) throw new Error(`Orders API ${res.status}: ${await res.text()}`);
+      return res.json();
+    },
+  });
+
+  rl.registerAction("create", {
+    description: "Create a new order",
+    inputSchema: {
+      orgId: { type: "string", required: true },
+      customer: { type: "string", required: true },
+      total: { type: "number", required: true },
+    },
+    async execute(input, ctx) {
+      const res = await fetch(`${ctx.connection.config.baseUrl}/orders`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${ctx.connection.config.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(input),
+      });
+      if (!res.ok) throw new Error(`Orders API ${res.status}: ${await res.text()}`);
+      return res.json();
+    },
+  });
+}
+```
+
+Key points: `execute` runs **outside** the sandbox with full Node.js access (fetch, fs, etc). The sandbox can only call your actions through the proxy. `ctx.connection.config` holds the resolved config with env var overrides applied.
+
+See [plugins/](plugins/) for 188 real-world examples.
+
+## Sandbox
+
+Agent code runs in a [QuickJS](https://bellard.org/quickjs/) WASM sandbox:
+
+- **No `fetch`** — network access is only through plugin actions
+- **No `fs`** — no filesystem access
+- **Timeout** — configurable, kills infinite loops
+- **Memory limit** — configurable, prevents OOM
+- **`console.log`** — captured and returned in `result.logs`
+- **Plugin globals** — each installed plugin is a top-level proxy (e.g. `github`, `slack`, `brandfetch`). Dot-chain into resource and action: `github.issue.create(input)`
+
+## For Agents
+
+Every command supports `--json`. Use `runline actions --json` for full schemas with input types.
+
+```bash
+runline actions --json          # all actions with schemas
+runline exec '<code>' --json    # structured { result, logs } output
+```
+
+## SDK
+
+```typescript
+import { Runline } from "runline";
+import brandfetch from "runline-plugin-brandfetch";
+
+const rl = Runline.create({
+  plugins: [brandfetch],
+  connections: [{ name: "bf", plugin: "brandfetch", config: { apiKey: "xxx" } }],
+});
+
+const result = await rl.execute(`
+  const colors = await brandfetch.brand.getColors({ domain: "stripe.com" });
+  return colors.filter(c => c.type === "accent");
+`);
+
+console.log(result.result);  // [{ hex: "#635BFF", type: "accent", brightness: 116 }]
+```
+
+## CLI Reference
+
+```bash
+runline exec "<code>"                  # execute JS in sandbox
+runline exec -f ./script.js            # execute a file
+runline actions                        # list all actions
+runline plugin install <source>        # install from git/npm/local
+runline plugin list                    # list installed plugins
+runline plugin remove <name>           # remove a plugin
+runline connection add <n> -p <plugin> -s key=val  # add connection
+runline connection list                # list connections
+runline connection remove <name>       # remove a connection
+runline init                           # create .runline/ directory
+```
+
+## Configuration
+
+`.runline/config.json`:
+
+```json
+{
+  "connections": [
+    { "name": "gh", "plugin": "github", "config": { "token": "ghp_xxx" } },
+    { "name": "bf", "plugin": "brandfetch", "config": { "apiKey": "xxx" } }
+  ],
+  "timeoutMs": 30000,
+  "memoryLimitBytes": 67108864
+}
+```
+
+Env vars override config values. Plugins declare env var names in their connection schema (e.g. `GITHUB_TOKEN`).
+
+## Development
+
+```bash
+npm install
+npm run dev -- exec 'return 1 + 2'
+npm test
+npm run check
+```
+
+## How It Relates to dripline
+
+[dripline](https://github.com/Michaelliv/dripline) is **query mode** — SQL tables over live APIs. runline is **code mode** — JavaScript actions over the same APIs. Same plugin architecture, same connection config, different interface. Use dripline when you want to `SELECT` rows; use runline when you want to `create`, `update`, `delete`, or chain multiple API calls together.
+
+## License
+
+MIT

package/dist/commands/actions.d.ts

@@ -0,0 +1,3 @@
+export declare function actions(options: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/actions.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import { loadAllPlugins } from "../plugin/loader.js";
+import { registry } from "../plugin/registry.js";
+import { printJson } from "../utils/output.js";
+export async function actions(options) {
+    await loadAllPlugins();
+    const all = registry.getAllActions();
+    if (options.json) {
+        printJson(all.map(({ plugin, action }) => ({
+            plugin,
+            action: action.name,
+            description: action.description,
+            inputSchema: action.inputSchema,
+        })));
+        return;
+    }
+    if (all.length === 0) {
+        console.log("No actions registered. Install a plugin first.");
+        return;
+    }
+    const grouped = new Map();
+    for (const entry of all) {
+        const list = grouped.get(entry.plugin) ?? [];
+        list.push(entry);
+        grouped.set(entry.plugin, list);
+    }
+    for (const [plugin, entries] of grouped) {
+        console.log(chalk.bold(`\n${plugin}`));
+        for (const { action } of entries) {
+            const path = chalk.cyan(`${plugin}.${action.name}`);
+            const desc = action.description
+                ? chalk.dim(` — ${action.description}`)
+                : "";
+            const schema = action.inputSchema
+                ? chalk.dim(` (${Object.entries(action.inputSchema)
+                    .map(([k, v]) => `${k}: ${v.type}${v.required ? "" : "?"}`)
+                    .join(", ")})`)
+                : "";
+            console.log(`  ${path}${schema}${desc}`);
+        }
+    }
+    console.log();
+}

package/dist/commands/connection.d.ts

@@ -0,0 +1,11 @@
+export declare function connectionAdd(name: string, options: {
+    plugin: string;
+    set: string[];
+    json?: boolean;
+}): Promise<void>;
+export declare function connectionRemove(name: string, options: {
+    json?: boolean;
+}): Promise<void>;
+export declare function connectionList(options: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/connection.js

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import { addConnection, loadConfig, removeConnection, } from "../config/loader.js";
+import { printError, printJson, printSuccess } from "../utils/output.js";
+export async function connectionAdd(name, options) {
+    const configValues = {};
+    for (const kv of options.set) {
+        const eq = kv.indexOf("=");
+        if (eq < 0) {
+            printError(`Invalid --set value: ${kv} (expected key=value)`);
+            process.exit(1);
+        }
+        configValues[kv.slice(0, eq)] = kv.slice(eq + 1);
+    }
+    addConnection(name, options.plugin, configValues);
+    if (options.json) {
+        printJson({ ok: true, name, plugin: options.plugin });
+    }
+    else {
+        printSuccess(`Connection ${chalk.bold(name)} added (plugin: ${options.plugin})`);
+    }
+}
+export async function connectionRemove(name, options) {
+    const removed = removeConnection(name);
+    if (!removed) {
+        printError(`Connection "${name}" not found`);
+        process.exit(1);
+    }
+    if (options.json) {
+        printJson({ ok: true, removed: name });
+    }
+    else {
+        printSuccess(`Connection ${chalk.bold(name)} removed`);
+    }
+}
+export async function connectionList(options) {
+    const config = loadConfig();
+    const connections = config.connections;
+    if (options.json) {
+        printJson(connections.map((c) => ({
+            name: c.name,
+            plugin: c.plugin,
+            config: Object.fromEntries(Object.entries(c.config).map(([k, v]) => [
+                k,
+                typeof v === "string" && v.length > 8 ? `${v.slice(0, 4)}...` : v,
+            ])),
+        })));
+        return;
+    }
+    if (connections.length === 0) {
+        console.log("No connections configured.");
+        return;
+    }
+    for (const c of connections) {
+        console.log(`  ${chalk.bold(c.name)} (${c.plugin})`);
+    }
+}

package/dist/commands/exec.d.ts

@@ -0,0 +1,5 @@
+export declare function exec(code: string, options: {
+    file?: boolean;
+    json?: boolean;
+    quiet?: boolean;
+}): Promise<void>;

package/dist/commands/exec.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "node:fs";
+import { loadConfig } from "../config/loader.js";
+import { ExecutionEngine } from "../core/engine.js";
+import { loadAllPlugins } from "../plugin/loader.js";
+import { registry } from "../plugin/registry.js";
+import { printError, printJson } from "../utils/output.js";
+export async function exec(code, options) {
+    await loadAllPlugins();
+    const config = loadConfig();
+    const engine = new ExecutionEngine(registry, config);
+    if (options.file) {
+        if (!existsSync(code)) {
+            printError(`File not found: ${code}`);
+            process.exit(1);
+        }
+        code = readFileSync(code, "utf-8");
+    }
+    const result = await engine.execute(code);
+    if (result.error) {
+        if (options.json) {
+            printJson({ error: result.error, logs: result.logs });
+        }
+        else {
+            if (result.logs.length > 0 && !options.quiet) {
+                for (const log of result.logs)
+                    console.error(log);
+            }
+            printError(result.error);
+        }
+        process.exit(1);
+    }
+    if (options.json) {
+        printJson({ result: result.result, logs: result.logs });
+    }
+    else {
+        if (result.logs.length > 0 && !options.quiet) {
+            for (const log of result.logs)
+                console.error(log);
+        }
+        if (result.result !== null && result.result !== undefined) {
+            console.log(typeof result.result === "string"
+                ? result.result
+                : JSON.stringify(result.result, null, 2));
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function init(options: {
+    json?: boolean;
+    quiet?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,26 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { DEFAULT_CONFIG } from "../config/types.js";
+import { printJson, printSuccess, printWarn } from "../utils/output.js";
+export async function init(options) {
+    const dir = join(process.cwd(), ".runline");
+    if (existsSync(dir)) {
+        if (options.json) {
+            printJson({ ok: true, exists: true, path: dir });
+        }
+        else if (!options.quiet) {
+            printWarn(`${chalk.bold(".runline/")} already exists`);
+        }
+        return;
+    }
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(join(dir, "plugins"), { recursive: true });
+    writeFileSync(join(dir, "config.json"), `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`);
+    if (options.json) {
+        printJson({ ok: true, path: dir });
+    }
+    else if (!options.quiet) {
+        printSuccess(`Created ${chalk.bold(".runline/")} in current directory`);
+    }
+}

package/dist/commands/plugin.d.ts

@@ -0,0 +1,10 @@
+export declare function pluginInstall(source: string, options: {
+    global?: boolean;
+    json?: boolean;
+}): Promise<void>;
+export declare function pluginRemove(name: string, options: {
+    json?: boolean;
+}): Promise<void>;
+export declare function pluginList(options: {
+    json?: boolean;
+}): Promise<void>;