┌─────────────────────────────────────────────┐
│              Lark Client                      │
│  Messenger │ Docs │ Base │ Calendar │ Approval│
├────────────────────┬──────────────────────────┤
│  Custom App (H5)   │  Bot / Webhook            │
│  Docs Add-on       │  Event Subscription       │
│  Base Extension    │                           │
├────────────────────┴──────────────────────────┤
│           Lark Open Platform                  │
│   Server API  │  Event Sub  │  Message Card   │
├───────────────────────────────────────────────┤
│           Developer Console                   │
└───────────────────────────────────────────────┘
              ↕ REST API / WebSocket
┌───────────────────────────────────────────────┐
│  Your Backend (Node.js / Python / Go / Java)  │
│  SDK: @larksuiteoapi/node-sdk                 │
└───────────────────────────────────────────────┘

1. Developer Console でアプリ作成
2. App ID / App Secret 取得
3. 必要な権限（Scope）を設定
4. 機能を実装（Bot / Web App / API 呼び出し）
5. テスト・デバッグ
6. 管理者承認 → アプリ公開

LARK_APP_ID=cli_xxxxxxxxxxxx
LARK_APP_SECRET=xxxxxxxxxxxxxxxxxxxxxxxx
LARK_ENCRYPT_KEY=xxxxxxxxxxxx          # イベント暗号化（任意）
LARK_VERIFICATION_TOKEN=xxxxxxxxxxxx   # Webhook 検証用

POST https://open.larksuite.com/open-apis/auth/v3/tenant_access_token/internal

// リクエスト
{ "app_id": "cli_xxx", "app_secret": "xxx" }

// レスポンス
{ "code": 0, "tenant_access_token": "t-xxx", "expire": 7200 }

import * as lark from '@larksuiteoapi/node-sdk';

const client = new lark.Client({
  appId: process.env.LARK_APP_ID,
  appSecret: process.env.LARK_APP_SECRET,
  // domain: lark.Domain.Lark  // 海外版
});

1. 認証URLへリダイレクト
https://open.larksuite.com/open-apis/authen/v1/authorize
  ?app_id={app_id}&redirect_uri={uri}&state={state}

2. 承認 → redirect_uri に code が返る

3. code を access_token に交換
POST /open-apis/authen/v1/oidc/access_token
{ "grant_type": "authorization_code", "code": "{code}" }

// 受信
{ "challenge": "ajls384kdjx98XX", "type": "url_verification" }
// 返却
{ "challenge": "ajls384kdjx98XX" }

import * as lark from '@larksuiteoapi/node-sdk';
import express from 'express';

const client = new lark.Client({
  appId: process.env.LARK_APP_ID,
  appSecret: process.env.LARK_APP_SECRET,
});

const dispatcher = new lark.EventDispatcher({
  verificationToken: process.env.LARK_VERIFICATION_TOKEN,
}).register({
  'im.message.receive_v1': async (data) => {
    const { message } = data;
    const content = JSON.parse(message.content);
    if (message.message_type === 'text') {
      await client.im.message.create({
        params: { receive_id_type: 'chat_id' },
        data: {
          receive_id: message.chat_id,
          content: JSON.stringify({ text: `受信: ${content.text}` }),
          msg_type: 'text',
        },
      });
    }
  },
});

const app = express();
app.use('/webhook/event', lark.adaptExpress(dispatcher));
app.listen(3000);

curl -X POST 'https://open.larksuite.com/open-apis/bot/v2/hook/xxx' \
  -H 'Content-Type: application/json' \
  -d '{"msg_type":"text","content":{"text":"CPU使用率が90%を超えました"}}'

{
  "config": { "wide_screen_mode": true },
  "header": {
    "template": "blue",
    "title": { "content": "カードタイトル", "tag": "plain_text" }
  },
  "elements": [ /* 本文要素 */ ]
}

{
  "tag": "action",
  "actions": [
    { "tag": "button",
      "text": { "tag": "plain_text", "content": "承認" },
      "type": "primary", "value": { "action": "approve" } },
    { "tag": "button",
      "text": { "tag": "plain_text", "content": "却下" },
      "type": "danger", "value": { "action": "reject" } }
  ]
}

await client.im.message.create({
  params: { receive_id_type: 'chat_id' },
  data: {
    receive_id: 'oc_xxx',
    msg_type: 'interactive',
    content: JSON.stringify({
      header: { template: 'green',
        title: { content: 'デプロイ完了', tag: 'plain_text' } },
      elements: [
        { tag: 'markdown', content: '**v1.2.3** を本番にデプロイしました' },
        { tag: 'hr' },
        { tag: 'action', actions: [
          { tag: 'button', type: 'primary',
            text: { tag: 'plain_text', content: 'ログを確認' },
            url: 'https://example.com/logs' } ] },
      ],
    }),
  },
});

const handler = new lark.CardActionHandler({
  verificationToken: process.env.LARK_VERIFICATION_TOKEN,
});
handler.register((data) => {
  console.log('アクション:', data.action.value);
  return {   // 更新後のカードを返す（任意）
    header: { template: 'green',
      title: { content: '承認済み', tag: 'plain_text' } },
    elements: [ { tag: 'markdown', content: '承認が完了しました' } ],
  };
});
app.use('/webhook/card', lark.adaptExpress(handler));

{
  "code": 0,          // 0 = 成功, 非0 = エラー
  "msg": "success",
  "data": { /* レスポンスデータ */ }
}

npm install @larksuiteoapi/node-sdk

import * as lark from '@larksuiteoapi/node-sdk';

const client = new lark.Client({
  appId: 'cli_xxx',          // 必須
  appSecret: 'xxx',           // 必須
  domain: lark.Domain.Lark,     // Lark(海外) / Feishu(中国)
  appType: lark.AppType.SelfBuild, // SelfBuild / ISV
  loggerLevel: lark.LoggerLevel.INFO,
});

// メッセージ送信
const res = await client.im.message.create({
  params: { receive_id_type: 'chat_id' },
  data: {
    receive_id: 'oc_xxx',
    content: JSON.stringify({ text: 'hello world' }),
    msg_type: 'text',
  },
});
console.log(res.code, res.msg, res.data);  // 0, "success", {...}

for await (const items of await client.contact.user.listWithIterator({
  params: { department_id: '0', page_size: 20 },
})) {
  console.log(items);
}

const dispatcher = new lark.EventDispatcher({
  encryptKey: 'encrypt_key',            // 任意
  verificationToken: 'verification_token',
}).register({
  'im.message.receive_v1': async (data) => { /* ... */ },
});

// Express / Koa アダプタ
app.use('/webhook/event', lark.adaptExpress(dispatcher));

// アップロード
const res = await client.im.file.create({
  data: { file_type: 'mp4', file_name: 'test.mp4',
    file: fs.readFileSync('path/to/file.mp4') },
});

// ダウンロード
const resp = await client.im.file.get({ path: { file_key: 'file_key' } });
await resp.writeFile('output.mp4');

const res = await client.request({
  method: 'POST',
  url: '/open-apis/some/new/endpoint',
  data: { key: 'value' },
});

pip install lark-oapi

import lark_oapi as lark

client = lark.Client.builder() \
    .app_id("cli_xxx") \
    .app_secret("xxx") \
    .domain(lark.LARK_DOMAIN) \
    .log_level(lark.LogLevel.DEBUG) \
    .build()

from lark_oapi.api.im.v1 import *

request = CreateMessageRequest.builder() \
    .receive_id_type("chat_id") \
    .request_body(CreateMessageRequestBody.builder()
        .receive_id("oc_xxx")
        .msg_type("text")
        .content('{"text": "hello world"}')
        .build()) \
    .build()

response = client.im.v1.message.create(request)
if not response.success():
    print(f"Error: {response.code} - {response.msg}")
else:
    print(response.data)

def handle_message_receive(data: P2ImMessageReceiveV1) -> None:
    print(f"受信: {data.event.message.content}")

event_handler = lark.EventDispatcherHandler.builder("", "verification_token") \
    .register_p2_im_message_receive_v1(handle_message_receive) \
    .build()

@app.route("/webhook/event", methods=["POST"])
def event():
    return lark.flask_dispatcher(event_handler)

Bitable App (アプリ / app_token)
  └── Table (テーブル / table_id)
        ├── Field  (フィールド/列, 型付き / field_id)
        ├── Record (レコード/行 / record_id)
        └── View   (ビュー / view_id)
              Grid / Kanban / Gallery / Gantt / Form / Calendar

https://xxx.larksuite.com/base/BascXXXXXX?table=tblYYYYYY&view=vewZZZZZZ
                               ^^^^^^^^^^         ^^^^^^^^^      ^^^^^^^^
                               app_token          table_id       view_id

// 作成
await client.bitable.appTableRecord.create({
  path: { app_token: APP_TOKEN, table_id: tableId },
  data: { fields: {
    'タスク名': 'API設計',
    'ステータス': '未着手',
    '期限': 1710288000000,  // Unix timestamp (ms)
  } },
});

// 一覧
const res = await client.bitable.appTableRecord.list({
  path: { app_token: APP_TOKEN, table_id: tableId },
  params: { page_size: 100 },
});

// 更新 / 削除
await client.bitable.appTableRecord.update({
  path: { app_token: APP_TOKEN, table_id: tableId, record_id: recId },
  data: { fields: { 'ステータス': '進行中' } },
});
await client.bitable.appTableRecord.delete({
  path: { app_token: APP_TOKEN, table_id: tableId, record_id: recId },
});

params: {
  page_size: 100,
  filter: JSON.stringify({
    conjunction: 'and',
    conditions: [
      { field_name: 'ステータス', operator: 'is', value: ['未着手'] },
    ],
  }),
  sort: JSON.stringify([ { field_name: '期限', desc: false } ]),
}

async function getAllRecords(tableId) {
  const all = [];
  let pageToken;
  do {
    const res = await client.bitable.appTableRecord.list({
      path: { app_token: APP_TOKEN, table_id: tableId },
      params: { page_size: 500, ...(pageToken ? { page_token: pageToken } : {}) },
    });
    all.push(...(res.data?.items || []));
    pageToken = res.data?.has_more ? res.data.page_token : undefined;
  } while (pageToken);
  return all;
}

import './App.css';
import { bitable, IOpenSegmentType } from "@base-open/web-api";
import { Button } from '@douyinfe/semi-ui';

const findText = 'hi';        // 検索する文字列
const replaceText = 'hello';  // 置換する文字列

export default function App() {
  const replace = async () => {
    const selection = await bitable.base.getSelection();
    const table = await bitable.base.getTableById(selection?.tableId!);
    const fieldMetaList = await table.getFieldMetaList();
    const textField = fieldMetaList.find(({ name }) => name === 'Multiline' || name === '多行文本');
    const recordIdList = await table.getRecordIdList();
    for (let i = 0; i < recordIdList.length; i++) {
      const cellString = await table.getCellString(textField?.id!, recordIdList[i]!);
      if (cellString?.includes(findText)) {
        const newText = cellString.replaceAll(findText, replaceText);
        await table.setCellValue(textField?.id!, recordIdList[i]!, [{
          type: IOpenSegmentType.Text,
          text: newText,
        }]);
      }
    }
  };

  return (
    <main>
      <Button theme='solid' type='primary' onClick={replace}>Replace hi to hello</Button>
    </main>
  );
}

import lark from '@nicegoodthings/jssdk';

lark.ready(() => console.log('Lark JS SDK ready'));
lark.error((err) => console.error(err));

// 機能利用前に config で認証（署名はサーバーで生成）
lark.config({
  appId: 'cli_xxx',
  timestamp: '...', nonceStr: '...', signature: '...',
  jsApiList: ['getUserInfo', 'chooseImage', 'scanCode'],
});

# Web App を直接開く
https://applink.larksuite.com/client/web_app/open?appId=cli_xxx&mode=sidebar
# チャットを開く
https://applink.larksuite.com/client/chat/open?chatId=oc_xxx

<view class="container">
  <text class="title">タスク一覧</text>
  <view tt:for="{{tasks}}" tt:key="id" class="task-item">
    <text>{{item.name}}</text>
    <button size="mini" bindtap="onComplete" data-id="{{item.id}}">完了</button>
  </view>
  <view tt:if="{{tasks.length === 0}}"><text>タスクはありません</text></view>
</view>

Page({
  data: { tasks: [], inputValue: '' },
  onLoad() { this.fetchTasks(); },
  async fetchTasks() {
    const res = await tt.request({ url: 'https://your-api.com/tasks', method: 'GET' });
    this.setData({ tasks: res.data });
  },
});

// Lark 連携
tt.login({ success: (res) => { /* res.code をサーバーへ */ } });
tt.scanCode({ success: (res) => console.log(res.result) });
tt.shareAppMessage({ title: '共有', path: '/pages/detail/detail?id=123' });

トリガー（イベント発生）
    ↓
条件分岐（フィルタリング）
    ↓
アクション（実行）
    ↓
通知（結果報告）

# GitHub Issue → Lark 通知
トリガー: GitHub で Issue 作成
  → 変換: タイトル・本文・ラベルを抽出
  → アクション: グループにメッセージカード送信

# 承認完了 → Base 更新 + メール
トリガー: Lark 承認が完了
  → 条件: 結果が「承認」
  → アクション1: Base のステータス更新
  → アクション2: 申請者にメール通知

import crypto from 'crypto';

function verify(timestamp, nonce, encryptKey, body, signature) {
  const str = timestamp + nonce + encryptKey + body;
  const hash = crypto.createHash('sha256').update(str).digest('hex');
  return hash === signature;
}
// リプレイ対策: timestamp が現在時刻の±5分以内か確認する

// 1. user_id_type の指定忘れ → params に必須
params: { receive_id_type: 'open_id' }

// 2. content が文字列でない → JSON.stringify 必須
data: { content: JSON.stringify({ text: 'hello' }) }

// 3. 日付の単位: Bitable=ミリ秒 / Calendar=秒(文字列)

app.post('/webhook', (req, res) => {
  if (req.body.type === 'url_verification') {
    return res.json({ challenge: req.body.challenge });
  }
  res.json({ code: 0 });               // 即座に応答
  processEvent(req.body).catch(console.error); // 重い処理は非同期
});